LLMs are non-deterministic. That's fine — that's their strength. But they cannot be trusted to orchestrate. reBe gives you both: a WASM flow runtime that is deterministic by construction, and LLM steps that operate within it under contract.
The flow runs on your hardware, reads from your corpus, executes locally, and writes to an immutable chronicle. No cloud dependency. No usage meter. No data leaving your realm.
The flow is a contract. Each step has a type, an input schema, and an output schema. LLM steps are just another step type — bounded, testable, auditable.
your email, last 30 days
local model, bound schema
local model, bullet format
immutable audit record
import { getTheCy } from '@thecy/realm-client'
const cy = await getTheCy()
// Define a flow from composable WASM steps
const flow = cy.flows.define({
id: 'monthly-spend-review',
steps: [
{ id: 'collect', type: 'corpus.query', params: { slice: 'finance', window: '30d' } },
{ id: 'classify', type: 'llm.categorise', params: { model: 'local', schema: SpendSchema } },
{ id: 'summarise',type: 'llm.summarise', params: { model: 'local', format: 'bullets' } },
{ id: 'record', type: 'chronicle.append', params: { thing: cy.identity.thingId } },
],
})
// Run it — deterministic structure, LLM fills 'classify' and 'summarise'
const result = await flow.run()
// → chronicle entry written, audit-safe, ran entirely on your hardwareYou don't choose between deterministic and non-deterministic. You compose them. The flow enforces the structure. The LLM fills in the creative work. The chronicle makes it auditable either way.
| Aspect | deterministic | llm step |
|---|---|---|
| Orchestration | WASM flow definition — same structure every run | LLM generates the flow from a natural language description |
| Step execution | Pure functions: input schema → output schema, no side effects | LLM fills a step: prompted with context, bound by output schema |
| Audit | Chronicle records every step: inputs, outputs, duration, actor | LLM response is recorded verbatim — non-determinism is traceable |
| Testing | Flow structure is testable — run against fixture corpus, assert outputs | LLM steps are evaluated — prompt + rubric, scored by local model |
| Trust boundary | Compliance-safe: auditor sees the flow, the inputs, the outputs | LLM steps are bounded — they cannot escape the flow contract |
A flow written at T0 runs identically at T1, T2, and T3. Scale is a deployment decision, not a rewrite. The WASM binary is the same — only the compute and corpus change.
T3 — CSP Edge available for operator deployments. thecy.io/operators ↗
You describe a process in natural language or voice. A local distilled LLM generates a verifiable flow from composable WASM parts. You inspect it in plain language — “this step looks wrong” — and regenerate. No IDE. No deployment pipeline. No syntax error.
The flows you define are yours. They live in your realm. They read from your corpus. They write to your chronicle. You grant permission for other Things — people, agents, automations — to invoke them. You revoke it. You delete them. No platform owns the execution.
Every step is a WASM module. Modules are composable, testable in isolation, replaceable without touching the flow. The LLM-generated step for “classify by project” can be replaced with a deterministic classifier once you have enough examples. The flow contract stays the same.
When a local LLM generates a flow, it also generates tests — prompt templates, fixture corpus, expected output schemas. Before the flow is deployed, it runs against your real data. You see pass/fail per step. If a step fails, you tell the model what was wrong in plain language and it regenerates.
Not one large general model. A portfolio of small, distilled models optimised for specific functions: classification, summarisation, extraction, code generation, question-answering. Each runs locally at T1. Each is replaceable. None requires a cloud API call.
A compliance team can read the chronicle entry for any flow execution: who invoked it, what corpus slice was read, what the LLM step received as input, what it returned, what happened next. The trust is in the structure, not in a vendor's audit dashboard.
Zapier, n8n, Temporal, Prefect — all SaaS platforms or self-hosted services. Your flows depend on their uptime, their pricing, their architecture decisions. reBe flows are WASM binaries. They run wherever WASM runs.
| Dimension | Workflow tools | reBe flows |
|---|---|---|
| Orchestration | Central SaaS scheduler | WASM flow — runs anywhere |
| LLM role | Agent drives the process | LLM fills bounded steps |
| Data | Sent to cloud for processing | Stays on device/LAN |
| Audit trail | Platform logs (opaque) | Chronicle — cryptographic, immutable |
| Scale | Pay per execution, per seat | Hardware you own — no meter |
| Deployment | SaaS or self-hosted service | WASM binary — browser, Pi, K3s, edge |
| Identity | OAuth, platform-managed | Cryptographic realm identity |
The Flow Builder, Developer IDE, and reBe Agent are running inside reBe right now. Your realm boots in the browser — no install, no account, no cloud.
Open the XyFlow canvas. Drag nodes, wire steps, run your first flow against real corpus data. Deterministic by construction.
PTY terminal, flow orchestrator, provisioning wizard, party line. Everything you need to build and operate a sovereign app.
Describe what you want to automate. reBe generates a flow from your corpus context. Natural language to WASM flow.
Boots in the browser. No install. Your realm, your data, your hardware.
realm-client is in active development. The T0 browser layer is production-ready. T1 node and T2 lattice federation are in beta. We're working with a small group of developers building the first sovereign-native applications — flows that run on hardware you own, read from corpus you control, and write to an audit log that belongs to you.
theCy is the platform. reBe is the personal layer built on it.
For IT teams, managed service providers, and VARs — reBe is a deployable sovereign stack. You provision realms for clients, manage the fleet, brand the experience, and own the relationship. Your clients get sovereign AI and data sovereignty. You get recurring infrastructure revenue without hyperscaler margin compression.
Deploy reBe under your brand. Your clients see your name on their sovereign platform. You manage the infrastructure, they own their data. The relationship is yours.
Provision, update, and manage hundreds of client realms from one console. Per-realm policy. Per-realm corpus governance. Central audit trail.
Build and ship pre-loaded corpus for a vertical — healthcare, legal, construction, finance. Your expertise + reBe sovereignty = a differentiated offering.
No per-token cloud cost means your margin is your infrastructure margin. Fixed hardware cost, unlimited inference — unit economics improve with scale.
Deploy reBe as a managed service. White-label it. Build vertical-specific corpus. Earn recurring infrastructure revenue. Your clients get sovereignty. You own the relationship.
Contact us →Open this Studio piece and ask reBe how to build a capability — Things, asCode, Operator.
Open the piece on Studio →