AI where it helps.
Determinism where it matters.
A coworker that lives in your inbox and reasons with you. A decision service that answers the same way every time, in a millisecond. An integration platform where the AI writes the flow and then gets out of the way. Use one. Or let them work together.
The Stripe failure is the 3rd from Acme this quarter — I pulled the others from your Postgres. Want me to draft a reply to Jane asking about payment method, log a refund-request entry, AND open a microapp to track future Acme charges?
Three jobs. Three products. The right amount of AI in each.
Some work needs judgement — reading a thread, deciding what to say. Some work must never need it — pricing a basket, routing a ticket, moving a record. We built a product for each, and they call each other over plain APIs.
The AI work companion
Triage mail, query 14 databases in English, summon a microapp, automate the routine. Reasons at runtime, remembers what you told it, seals every action.
Judgement, on demand →
Business rules as an API
Typed inputs, rules with priorities, safe formulas. One POST, one millisecond, the same answer every time. Per-tenant, versioned, cached.
No judgement, by design →
Integration that compiles
Describe the flow in plain English. The LLM compiles it into a verified, signed artifact — then a runtime with no AI in it runs it. 0 ms inference in production.
Judgement at design time only →
The AI coworker that lives in your inbox.
Email is where work happens. We made it where AI work happens. Runs in your browser, or on your own hardware with one docker-compose. Bring your own LLM key, or point it at a local model. Live today at app.oentity.org, free tier, no card.
Six capabilities. One companion.
Not a chat sidebar tacked onto an old app. A coworker that lives in every screen of the client, with access to your mail, your data, and the systems you've already paid for.
Email & chat-native AI
Triage your inbox. Draft replies in your voice. Summarize threads. Extract action items into a microapp or task. Message the same companion from WhatsApp or Telegram — one coworker, every channel you already use.
Data integration
Connect Postgres, MySQL, SQL Server, Oracle, Snowflake, BigQuery, Databricks, Redshift, MongoDB and more — 14 databases in all. Ask in plain English. The companion reads your schema first, runs read-only queries, and answers in words, a table, or a chart.
Summoned microapps
"Build me a refund tracker." Get a working app with forms, KPIs, dynamic tables, and AI actions that summarise or draft on demand. Start from 13 ready-made templates or describe your own.
Legacy app integration
Query the SaaS apps you already pay for — Stripe, HubSpot, QuickBooks, PayPal, DocuSign — alongside your own databases, in one question. Reads only: nothing the companion does can change a record in them.
Task automation
Schedule the routine. Weekly customer digest. End-of-month finance close. Refund-decision queue checked every morning. The companion runs them, sealed and audited.
Knowledge + memory
Tell it once. "Anything over 48 hours is an escalation for us" — say that today and it still knows next week, in a different conversation. Cryptographic audit chain on every action.
Plugs into what you already pay for.
Your databases. Your SaaS tools. Your LLM accounts. Your own hardware. Each connection is per-tenant, encrypted at rest, and strictly read-only — the companion cannot write to your systems even if asked to.
- Per-tenant Fernet vault — keys never returned to client
- Read-only, enforced by a parser allow-list — not a keyword blocklist
- Tamper-evident audit chain (ImmuDB-sealed) on every action
- MCP server — your agents are also callable from Claude Desktop, Cursor, any MCP client
What a workday looks like with a companion.
Real jobs, start to finish — read your mail, query your data, act in the tools you already pay for, and seal it in the audit chain. No prompt engineering required.
Chase every failed payment
"Any Stripe charges bounce this week? Who, how much, and is it a repeat?"
- 1Pulls failed charges from Stripe, cross-checks history in Postgres
- 2Drafts a dunning email in your voice, flags 3rd-strike accounts
- 3Summons a refund tracker microapp for the repeat offenders
Monday metrics, on autopilot
"Every Monday, send me last week's numbers with what changed and why."
- 1Runs read-only SQL across Postgres + Google Sheets on schedule
- 2Builds the charts, writes the narrative — what moved, week over week
- 3Emails the digest and posts it to Slack — sealed in audit
Web client live · macOS, Windows, iOS and Android builds in development · self-host with one docker-compose.
Business rules as an API. One millisecond to an answer.
Pricing, eligibility, routing, risk, compliance — the decisions your business makes ten thousand times a day should not depend on a model's mood. Write them as a table of typed inputs and rules. Call it with a POST. Get the same answer every time, with the rule that produced it.
- Tenant isolation by construction — every table is keyed by tenant; the tenant comes from a verified token or an API key you minted, never a request body
- Refused before it can fail — values, formulas and column names are checked when a table is saved, not at the first live call
- Safe formulas —
round(amount * 0.15, 2)and the rest of arithmetic, sandboxed; nothing reaches the host, and the tests try - Fast enough to sit in the checkout — compiled tables cached in Redis and in process; p50 under 1 ms, p95 under 2 ms over HTTP
- Versioned, with history — stage a draft, publish it as the next version, pin any version on a call, roll back as a new version; history is never rewritten, and every answer carries the version that produced it
- A decision log — every evaluation kept: inputs, the rule that fired, outputs, version, and who called; "why did customer X get that result" is one GET
- Simulate before you publish — run cases with expected results against the draft, a version or an unsaved definition; nothing is logged or counted
- Judgements, when an input is a call rather than a fact — "is this message angry?", "what is it about?": a decision model (Cloudflare's Clef-flash, or TypeSafe's Jev) answers with a calibrated probability, and the rules test the answer and its confidence like any other input. Not an LLM: no text is generated, the model version is pinned, and the rules still decide
- API keys and plans — keys scoped to evaluate or manage, per-tenant limits on tables, evaluations a month and requests a second, and a usage endpoint that shows where you stand
Early access. The service runs today as one container plus Postgres and Redis — self-host it with a single docker-compose, or use ours at app.oentity.org. Everything above ships: history and rollback, the decision log, simulation, judgements, keys and plans, and a grid editor inside the OEntity shell so a business user never sees JSON. What we are building now: rule analysis (overlapping and unreachable rules) and DMN import. Pricing is announced at general availability; early-access partners get founding terms.
Describe the integration. Run it without the AI.
Every "AI automation" tool runs a model at every step of every run — slow, expensive, and a different answer on Tuesday. AI-ESB puts the model where it belongs: at design time. It compiles your sentence and your API schemas into a typed plan, verifies and sandbox-tests the code, signs the artifact — and then a runtime with no AI in it runs that artifact, for ever, the same way.
Plain English in. A typed plan out.
"When a row lands in the sales sheet, look the company up in HubSpot, classify the intent, and email the rep." The compiler grounds every step against the connector catalog and the schemas you connected — and refuses anything it cannot ground.
Static verifier, sandbox, signature.
The emitted code is checked against the plan, run in an isolated microVM with no network against a mock fabric, repaired within a bounded loop, and signed. You read the plan in English, approve, and promote. What runs is exactly what you approved.
0 ms inference. Predictable errors.
The runtime has no model in the loop: explicit retries, dead-letter queue, replay, a derived egress allowlist you can read. Where you want a model — "classify the intent" — it runs as one step under a signed contract, and its answer is validated against that contract before anything downstream sees it.
Early access. Compiler, sandbox, runtime, control plane and the builder UI run end to end today; the flow above is live on it. We are onboarding a small number of pilot teams while we finish the connector foundry and the hosted edition.
Three products, one spine.
Each one stands alone — buy one, run one, never hear about the others. But they were built to hand work to each other over plain APIs, and that is where the whole becomes more than the parts.
Where judgement lives
The companion reads the thread, pulls the numbers, remembers what you told it last month — and notices that "anything over 48 hours is an escalation" is a rule, not a conversation.
Where the rule is written down
That sentence becomes a table you can read, test and version. The companion drafts it; you approve it; from then on the answer is deterministic, audited, and a millisecond away — for the companion, for AI-ESB, and for your own code.
Where the work gets done
"Make this automatic" from a conversation becomes a signed flow: the spreadsheet row arrives, the table decides, the CRM is updated, the rep is emailed. The policy can change without recompiling the flow — the flow pins the table's version.
Honest footnote: today the three integrate over their published APIs and each ships on its own schedule. The companion-drafts-a-table and AI-ESB-calls-a-table integrations are on the roadmap below, not on the live product yet.
Pay only for the AI you actually use.
Every plan includes a monthly token allowance — go over and you're billed by the token, never by the seat. Bring your own LLM key and those turns are free. Run a local model or self-host for zero LLM spend.
What does a token buy?
A "turn" is one question and everything the companion does to answer it — reading your schema, running the queries, building the chart. Measured on the live platform:
So the free tier's 2M is roughly a hundred real questions a month. Paid plans are less about volume than which model answers: Growth and above run on the smarter tier. Connect your own OpenAI or Anthropic key and nothing is metered, on any plan.
The free tier is live and self-serve — sign up and the 2M monthly tokens are yours, no card. Paid plans are priced and metered but not yet purchasable; we'll open them when checkout is ready. Start free →
- ✓ 2M tokens / month — about 100 questions
- ✓ 1 mail account · 1 data source
- ✓ Standard model tier
- ✓ Web client
- ✓ Or bring your own key — free turns
- ✓ 4M tokens / month — on the smarter model
- ✓ 5 data sources · 5 seats
- ✓ Standard + Advanced models
- ✓ Email support
- ✓ 10M tokens / month
- ✓ Unlimited data sources & seats
- ✓ All channels — Telegram, WhatsApp, email
- ✓ All models incl. Premium + model pinning
- ✓ Audit trail · priority support
- ✓ Volume token allowance
- ✓ Unlimited everything
- ✓ SSO / SAML · audit export
- ✓ SLA · dedicated CSM
- ✓ Self-host option
Free during early access, hosted by us or self-hosted from the same compose file. The free tier is real and enforced today: 3 tables, 10,000 evaluations a month, 10 requests a second, a 7-day decision log. Pricing at general availability will be per table and per evaluation — never per seat. Founding partners keep founding terms.
Request early access →Pilot teams run on founding terms while we finish the hosted edition. The model at GA: a flat monthly plan by number of live flows, with runs unmetered — there is no inference in the runtime, so there is nothing to meter. A sovereign tier runs the same signed bundles in your own VPC.
Request a pilot →What each product is building next.
Three roadmaps, one direction: the companion drafts, the tables decide, the flows execute — and you can read every step.
- Agent-to-agent collaboration — Inbox, Data and CRM specialists handing work to each other over the event bus
- Microsoft 365 & Gmail OAuth — one-click mail connect, no app passwords
- "Write that down as a rule" — the companion drafts a decision table from what you told it
- SSO & high availability for teams that outgrow a single box
- Version history, draft/publish, rollback, pinned evaluation
- Decision log — every evaluation, its inputs, version, matched rules and caller, retained per plan
- Simulation — cases with expected results against a draft, a version or an unsaved table
- Judgements — a decision model (Clef-flash or Jev) answers typed questions about the inputs with calibrated probabilities the rules then test
- API keys, plans and quotas on the hosted edition
- Grid editor in the OEntity shell — author, try and publish a table without touching JSON
- Rule analysis and DMN import — overlapping and unreachable rules; migrate from DMN FEEL
- Metering and billing at general availability
- Connector foundry — any OpenAPI schema becomes a reviewed, catalogued connector
- Google Sheets & Gmail API sources — beyond watched folders and SMTP
- Bare-metal containment CI — the sandbox boundary proven on real hardware on every build, not a laptop
- Kafka, SFTP, JMS — the next transport families on the same spine
- A "decide" step that calls a pinned Decision Tables version
Start with the one you need today.
The companion is free and live. The other two are a conversation away — and all three run on your own hardware if that is where your data has to stay.