The platform underneath the production layer.
Composable functions you chain into workflows. Observability and evals on every function. Automatic model upgrades behind a stable API. Multi-cloud, Private Link, on-prem, EU regions. The platform that ships into the security posture your customers already expect.
First 100 function calls every month, free. No credit card. No sales call required.
Seven primitives. One contract.
Each function is a pure, versioned, schema-typed operation. Use one in isolation, or compose them into a workflow your team can ship in minutes. Every call returns strict-typed JSON, a per-field confidence score, and an audit trail.
Turn any file into structured JSON in seconds.
The most-used function on the platform. Multi-modal in, schema-typed out, with a confidence score on every field. A classifier picks from 15+ models per file and upgrades them behind a stable API. You write the schema once. We handle the rest.
A 47-page claims packet, in one call.
{
"claim_id": "C-2026-0428-991",
"claimant": {
"name": "Daniel R. Carmichael",
"dob": "1972-11-04",
"policy": "PRX-487-A"
},
"incident": {
"date": "2026-04-21",
"type": "auto_collision",
"severity_score": 0.81
},
"documents": 47,
"confidence": 0.972
}Identify the input type and route it to the right workflow. Customer taxonomies, learned over time.
Turn raw unstructured input into a clean, machine-readable representation the rest of the pipeline can operate on.
Semantically break a multi-document packet into individual records and classify each one. Map-reduce for files.
Three-way matches across inputs and systems of record. Reconcile invoice, PO, and goods receipt in one pass.
Resolve entities against your CRM, ERP, and internal datasets. Augment fields with what you already know.
Format the final structured output against the exact schema your downstream system expects.
Functions chain into workflows your team can ship.
A workflow is a versioned graph of functions, branching logic, and fallback states. Define the path, the thresholds, and the human-review behavior. We execute it with idempotent semantics, full state management, and end-to-end traceability.
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ CLASSIFY │ ─► │ PARSE │ ─► │ EXTRACT │
│ taxonomy │ │ multi-modal │ │ schema │
└──────────────┘ └──────────────┘ └──────┬───────┘
│
┌────────────────────────────┘
▼
┌──────────────────┐ ┌──────────────┐ ┌──────────────┐
│ SPLIT │ ─► │ ENRICH │ ─► │ JOIN │
│ packets → items │ │ CRM · ERP │ │ 3-way match │
└──────────────────┘ └──────────────┘ └──────┬───────┘
│
▼
┌────────────────────┐
│ PAYLOAD SHAPING │
│ → downstream API │
└────────────────────┘
│
confidence < threshold ?
│
▼
┌────────────────────┐
│ HUMAN REVIEW │
│ corrections loop │
└────────────────────┘Probabilistic AI requires deterministic guardrails.
Production accuracy is a system property, not a model property. Bem treats accuracy like code coverage: golden datasets, regression tests, drift detection, and a review queue that doubles as training data.
Accuracy scores
Precision, recall, F1, and threshold analysis on every function. Compare versions, model variants, and customer cohorts side by side.
Human review
Type-safe schemas flag low-confidence outputs into a built-in inbox. Operators label, correct, and approve in one place. Corrections become training data immediately.
Fine-tuning
Custom models trained on your schema and your corrections. Auto-retraining, model versioning, instant rollback, and per-customer accuracy that compounds.
{
"regression_id": "reg_89234",
"function": "extract.run",
"baseline_version": "v1.2.0",
"current_version": "v1.3.0-rc1",
"samples": 500,
"precision": 0.994,
"recall": 0.991,
"f1": 0.992,
"drift_detected": false,
"field_threshold_breaches": [],
"verdict": "promote"
}Forge for the no-code parts. AI Forms for the user-facing parts.
Two surfaces sit on top of the same V3 API. Forge composes workflows visually. AI Forms turns those workflows into auto-generated user-facing forms you can embed or login-gate. The teammates who don't live in code get the same primitives the engineers do.
Visual workflow builder.
Drag, drop, and connect functions. Define schemas inline. Promote to production without writing a line of code. The same workflow runs behind your API key.
Auto-generated user-facing forms.
Every workflow exposes an AI Form. Upload a file, the form fills itself. Operators edit anything that looks wrong. Submissions flow back into the same audit trail.
One V3 API. Four SDKs. A Terraform provider and a CLI.
Everything in Bem is an API call. The SDKs are auto-generated, fully typed, and published per release of the platform. Define functions and workflows as code, version them in your repo, and roll forward or back with the same primitives as your application.
import { Bem } from "@bem/sdk";
const bem = new Bem({ apiKey: process.env.BEM_API_KEY });
// 1. Run a single function
const extracted = await bem.functions.extract.run({
file: await fs.readFile("claim_packet.pdf"),
schemaId: "claim_v3",
});
// 2. Or call a full workflow you composed in Forge
const workflow = await bem.workflows.run("claims-intake", {
inputs: { file: extracted.file_id },
metadata: { policy_id: "PRX-487-A" },
});
workflow.outputs; // strict-typed JSON
workflow.confidence; // per-field confidence
workflow.review_queue_id; // present if any field crossed threshold
workflow.audit_trail; // every step, every model, every scoreMulti-cloud. Private Link. On-prem. EU sovereignty.
Bem ships into the deployment surface your security team already expects. Start on the multi-tenant cloud, move to Private Link as you scale, and run on-premise or in your own VPC when you need to. Same V3 API, same SDKs, same evals.
Built for regulated industries from day one.
Compliance, deployment, and procurement-ready from your first call. Bem ships into the security posture your customers already expect.
Build in minutes. Start for free.
Whether it's our no-code builder or APIs, ship your first workflow in minutes, not days. Get the first 100 function calls for free, then pay-as-you-go with graduated pricing.