OneUI
Back
Available now

OneUI — the AI Development Platform for building enterprise AI apps

Deterministic tools and rules do the work; LLMs orchestrate, summarize, and explain. OneUI streams structured outputs (ChatBlocks) with policy, receipts, and audit built in. Deploy in your Kubernetes cluster or cloud.

Read OverviewSee ArchitectureStart a Pilot
Particularly suitable for AI apps supporting DevOps, Platform Engineering, and SRE workflows (IDP, golden paths, observability, policy). Early‑adopter pricing available.

What OneUI is

OneUI is an AI operating layer for work: a deterministic‑first platform that unifies chat, tools, agents, and enterprise systems behind a single interface. Typed tools, rules/DSL, and SQL routes handle critical tasks; LLMs plan and explain. The UI streams real‑time ChatBlocks (markdown/table/chart/job/form) and delivers web‑first answers with citations.

By combining explainable workflows, governance (policies, approvals, audit), and multi‑tenant isolation, OneUI lets internal developers ship reliable AI apps quickly—without rebuilding the AI plumbing.

Highlights
  • Deterministic‑first, LLM‑orchestrated
  • Web‑first answers with citations
  • Policy engine + receipts per run
  • Multi‑LLM routing (A/B, failover)
  • Durable memory (Postgres + Kafka)
  • Deploy in your K8s or cloud

Core Capabilities

Deterministic Core
Typed tools, rules/DSL, and SQL routes; real‑time NDJSON streaming into ChatBlocks.
Multi‑LLM Router + Policy
Route across providers (A/B, failover); pre/tool/post policy hooks (redaction, approvals, budgets).
Durable Memory & Audit
Postgres + object storage; Kafka topics; MemoryCards; receipts with stable trace_id.
Agents & MCP
Deep Research agent with eval harness; MCP Host/Client to connect and control external tool servers.
Integrations & Data
Google/Microsoft; Sheets→SQL; HubSpot/Proxycurl; QuickBooks→Cloud SQL→Metabase; n8n automations.
Tenancy & Governance
Namespaced isolation; policy‑gated tools; SSO/SAML; PII tagging; egress allowlists; budgets/quotas.
Observability & Cost
Langfuse traces, Prometheus/Grafana metrics, Elastic logs; per‑tenant budgets and usage reports.

High‑Level Architecture

Frontend streams NDJSON into ChatBlocks; FastAPI backend handles routes, policy, multi‑LLM routing, deterministic tools, and the MCP gateway; memory & retrieval backed by Postgres/pgvector + object storage and hybrid BM25+vector; Kafka topics for memory/jobs; workers for async tasks.

+-------------------+      +----------------------+      +--------------------+
|  Frontend (Next)  |<---->|  FastAPI Backend     |<---->|  LLM Providers     |
|  ChatBlocks/Agents|      |  Policy / Router     |      |  (OpenAI/Anth/Gem) |
+---------+---------+      |  Deterministic Tools  |      +---------+----------+
          |                |  MCP Gateway         |                |
          v                +----------+-----------+                |
   Streaming (NDJSON)                 |                            |
                                      v                            v
                              +---------------+            +-------------+
                              | Memory & RAG  |<---------->|  Web & APIs |
                              | Postgres+Obj  |            +-------------+
                              | pgvector/BM25 |
                              +-------+-------+
                                      |
                                      v
                              +---------------+
                              | Kafka Topics  |
                              | memory/jobs   |
                              +-------+-------+
                                      |
                                      v
                              +---------------+
                              | Workers/Jobs  |
                              +---------------+

Current Product Surfaces

Chat & Streaming
Conversational UI returns markdown/table/chart/job/form ChatBlocks in real time with citations.
Agents
Deep Research (multi‑step, tool calling, eval metrics); MCP Host/Client to register and call external servers.
Apps
Gmail/Drive (New from Prompt), Sheets/SQL/BigQuery, HubSpot/Proxycurl, QuickBooks→Metabase.
IDP: GitHub Control Room
Browse repos/refs/files today; PR assist mock; private flows via PAT/OAuth roadmap.
IDP: SRE Operations Cockpit
Dashboards for logs/metrics/traces/errors/SLOs/usage (cloud adapters WIP).
IDP: Runway Blueprints
/api/runway/gemini/generate returns strict JSON IaC bundles; validation and Open‑PR on roadmap.

Deployment Options

Cloud Run baseline

App + workers on Cloud Run; Cloud SQL; object storage; Secret Manager/KMS; Prometheus/Grafana.

Kubernetes path

GitOps via GitHub Actions → GHCR → Argo CD; per‑tenant namespaces; autoscaling workers; blue/green rollouts.

Tenant provisioning creates DB schema + storage prefix (and K8s namespace if applicable), then applies budgets, policy profile, and API keys. Secrets are stored via cloud Secret Manager/KMS.

Security & Governance

Namespaced multi‑tenant isolation (DB schemas, storage prefixes, optional K8s namespaces)

Policy gates with approvals; egress allowlists; role‑based access

SSO/SAML and OAuth2 patterns; PII tagging and redaction

Budgets and quotas per tenant; rate limits; audit logs

Receipts per run with trace_id; end‑to‑end lineage

Encrypted at rest and in transit; least‑privilege credentials

Observability & Cost Controls

Langfuse traces (prompts/tools/MCP spans) with cost accounting

Prometheus/Grafana metrics; Elastic structured logs

KPIs: TTFC 2s; p95 latency 12s (research); deterministic routes p95 ≤ 800ms

Usage dashboards; per‑tenant budgets and model reports

Near‑Term Roadmap

Next 30 days
  • MCP SSE streaming; server registry/tags; per‑server auth vault; policy gates; Langfuse spans per call
  • Eval golden sets; rubric scoring; red‑team checks; exportable reports
  • Runway: validate‑bundle API; Open‑PR; starter marketplace
Next 60 days
  • SRE adapters for CloudWatch/Cloud Logging and OpenTelemetry; runbooks; ChatOps actions with approvals
  • Private GitHub flows; Issues/PR triage agent
  • Cross‑agent memory and budget guardrails
Next 90 days
  • Drift detection/auto‑remediation; meta‑agent reasoning
  • Developer VMs orchestration; Unity/Blender MCP servers prod
  • Customer onboarding: namespace provisioning, budgets, policy profiles

FAQ

How is OneUI different from a generic “chatbot”?

Deterministic tools and rules do the work; LLMs orchestrate and format. Every run has a receipt and trace_id. Web‑first answers ship with citations; RAG is a controlled fallback.

Can we deploy in our own cloud and keep data isolated?

Yes. Baseline on Cloud Run + Cloud SQL, or deploy to your Kubernetes cluster via GitOps. Tenants are namespaced end‑to‑end (DB, storage, optional K8s namespaces) with budgets and policy gates.

What developer interfaces are available?

HTTP/JSON APIs, typed tools, and MCP interfaces. Streaming NDJSON returns ChatBlocks you can render directly in your UI.

Start a pilot or request access

We’ll help your team wire policy, receipts, and observability from day one. Early‑adopter pricing (up to 80% off) available.