Skip to content

About

Orama Lake: the sovereign AI stack. Use AI to easily Design, Train, and Ship your own custom models, agents, workflows, and warehouses to prod in minutes. MIT-licensed AI infrastructure that runs everywhere. Free, sovereign AI, for everyone.

Resources

Code of conduct

Contributing

Security policy

Stars

8 stars

Watchers

0 watching

Forks

Repository files navigation

Orama Lake: the sovereign AI stack

Own your AI

An AI easy button, with batteries included.

Everything you need to design, train, and ship real AI that learned on your own data,
on your own hardware, in minutes instead of months.


Ship a model to production with one prompt

$ git clone --recurse-submodules https://github.com/oramasearch/lake-platform.git
$ cd lake-platform
$ claude

> /lake design, train and ship a model to prod

Orama Lake is an AI platform. It lets you shift left, and makes it easier for your whole team to create and ship apps, agents and AI. You use AI to create and ship AI.

It's extensible, so your developers can grow it in the direction your team is going: any kind of model, on-prem or in any cloud, air-gapped if you need it, from supercomputers to embedded devices, with AI costs you control and any component yours to swap.

It's written almost exclusively in modern C++ (C++26), for maximum portability, distributed algorithms, and accelerator and device support. Every AI model runs on CPU, and uses custom GPU kernels to support any accelerator, for distributed training and inference. Training and inference can be hybrid, across different platforms and accelerators. With zetta, you can combine a "sky cluster" with private, firewalled nodes in one super cluster, for a hybrid of on-prem and cloud.

It's the same code that runs lake.live, and it's yours to build on.

Install

One cluster Everything on a single cluster. On a cluster you already have, it is the helmfile and one resource. On a fresh Linux machine, it is one script.
Management cluster One cluster that creates, runs, and manages other "leaf" Kubernetes clusters and their deployments (eg. multi-region, federated clusters/deployments, and globally-redundant deployments). You declare clusters and a LakeSet, and the operator keeps your Lakes running.

The whole guide is docs/install/.

Why Orama Lake

Demoware AI and apps are easy. Productionizing them is hard. Orama Lake is the force multiplier to productionize your apps, agents, data, and AI. One stack; infinite possibilities.

Anyone who has put AI into a real production environment knows how it goes. The demo takes an afternoon. Then, the real work starts.

The data it needs can't leave the building. Security asks where every record goes, and deserves an answer. The model needs somewhere to run, and what it reads needs somewhere to live. There has to be search, sign-in, a place for the secrets, a way to build it and a way to deploy it. Each piece comes from somewhere different, and somebody has to make them work together and keep them working.

The promise of AI is the promise of a smarter, more intelligent world. But, true AI requires training (or learning) on YOUR data.

The data that matters most is usually the data that can't be sent anywhere else. So the AI has to come to the data, and work inside the environment the data lives in, with all of its rules.

Orama Lake is what you get when the pieces are built as one stack, with one button to start it. From AI research to production in the same day.

What you get

Research to production, same day

Experiment tracking, a streaming agent substrate, and differential source control, builds and deploys are all one system. What works in an experiment in the morning can be in front of people by the evening.

Any model, for real-world solutions

Language models are one kind of AI among many. Train and run the models real problems call for: forecasts, classifiers, rankers, anomaly detectors, and language models too, each one learned on your own data.

Wherever you run

On-prem, in a private cloud, in a public cloud, or air-gapped, with a whole ecosystem inside the wall: the packages, the images, the models and the agents.

Whatever you run on

From supercomputers to embedded devices, on any accelerator, any cloud and any architecture.

Distributed from the start

Training, inference and agents all spread across a cluster, with agents working as swarms and as teams.

Agents that are trained, and checked

The agents are trained with reinforcement learning with verifiable rewards (RLVR): an agent is rewarded only when its work can be checked and is right.

AI costs you control

Models run on hardware you already own, every token is metered, and the limits are yours to set.

Free to embed in your products

Put Orama Lake inside what you sell, with full control over it. The license asks for no fee, no permission and no share of what you make.

Swap any part

Bring your own identity provider, or swap any other component for the one your team already trusts. Add any open-source database service, and any object storage.

SOC 2 compliant

The controls an audit asks for are part of the stack: signed history, access rules, audit trails, secrets and keys.

AI Projects: one ensemble

A project holds many models, workflows, agents, databases, storage and apps, all working together for one purpose.

Infrastructure as software

Spin up any infrastructure on the fly: clusters, DNS, buckets. It is always reconciling, and you can change it while it runs.

AI Projects

Real AI is rarely one model. It is a set of parts that have to work together, and an AI Project is where they live.

A project holds:

Models As many as the problem needs, of any kind
Workflows Execution graphs that run the steps in order
Agents Working alone, in teams or as swarms
Databases The data the project reads and writes
Storage Files and objects
Apps What people actually open and use

All of them work together as one ensemble, for one concerted purpose: a use case, or a whole project. You design it in one place, and you ship it as one thing.

Infrastructure as software

Orama Lake spins up any infrastructure on the fly: Kubernetes clusters, DNS records, object-storage buckets, and whatever else a project needs. Kris Nóva called it infrastructure as software.

Infrastructure as code Infrastructure as software
When it reconciles When someone runs it, or when an event fires Always, at runtime
Changing it Edit, plan, apply Mutable at runtime
What it is Files that describe a desired state A running program that keeps the state true

What that gives you:

  • Hyperconverged infrastructure, at far lower cost. Compute, data, storage and networking run together on the same clusters, so you run fewer machines and fewer services.
  • Better security isolation. Workloads run on dedicated Kubernetes leaf clusters, controlled by a single management cluster.
  • Easy to set up. The management cluster installs from a single helmfile.
  • 100% covered by MCP and the API. Everything the platform can do to infrastructure, a person, a script or an agent can do through MCP or the API, which makes it easy to operate.

Batteries included

The services a team would otherwise go and get one at a time are already in the box.

In the box
Design AI AI Projects that hold models, workflows, agents, databases, storage and apps as one ensemble · agents and apps built from a description · experiment tracking, from the first trial to the model in the registry · a streaming agent substrate, so agents react as events arrive and work together
Train AI Distributed gradient-boosted trees · exact explanations of every prediction · calibration · AutoML studies · a model registry · import of models in common open formats · synthetic data with differential privacy
Ship AI Differential source control, builds and deploys · image builds, a container registry and artifact storage · workflow pipelines, and agents on a schedule or from a stream
Your data An engine for storing and querying it · full-text search over data and documents · file storage and sharing, synced to a folder on your machine
Infrastructure Kubernetes clusters, DNS and buckets spun up on the fly · always reconciling, mutable at runtime · dedicated leaf clusters under one management cluster, installed from a single helmfile
Trust Signed provenance and an SBOM for every build · a transparency log and signed update metadata · secret scanning that blocks a leaked key before it lands
Connect MCP and the API cover 100% of the platform · MCP for every capability, and an MCP client with sign-in and approval for each tool · tunnels and a private network mesh with mutual TLS
Identity Sign-in for the apps you build · secrets and keys · a private certificate authority

Use Orama Lake instead of

Use Orama Lake instead of Palantir, Databricks, Snowflake, Railway, GitHub, Git and the long list of services around them. A team shipping AI usually buys each of these separately, then spends its time making them work together. Here they are one stack, on your own hardware, under one sign-in and one API.

AI: agents, models and training data

Instead of Such as Use
A decision platform Palantir Foundry and AIP zetta's decision-policy engine: versioned policies, approvals, holdouts, a ledger and return on investment, with apps and agents on top
A machine-learning platform AWS SageMaker, Vertex AI, Databricks ML, MLflow zetta and lake: distributed training, explanations, calibration, methodologies, experiments, a model registry, model import
Agent builders OpenAI Agents and Assistants, Microsoft Copilot Studio, LangGraph Platform agent-creator builds the agent you describe, and agent-runtime runs every agent you create
A chat assistant over your company's data ChatGPT Enterprise, Microsoft Copilot, Glean Ask Orama, on every page of lake
App builders Lovable, Bolt, Retool, Streamlit Community Cloud agent-application: builds web and data apps from a description, commits them and deploys them
Scoping what is worth building Consultancies, solution architects agent-autosuggest: reads your situation and your data, and proposes what to build
Pipeline and solution engineering Data engineering teams and contractors agent-project: builds and operates solutions and pipelines
AutoML and experiment design DataRobot, H2O Driverless AI, Vertex AutoML agent-experiments and zetta's AutoML studies, with experiment tracking
Evaluation of language models Braintrust, LangSmith, Patronus agent-eval-generator: writes the test cases agents are measured against
Bought or labelled training data Scale AI, Surge AI Generated training corpora
Synthetic data Gretel, Mostly AI zetta's differentially private synthetic data
Hosted model APIs The OpenAI, Anthropic and Google Gemini APIs base-agent-0.6b, a base model you run yourself
Rented training and inference Together AI, Fireworks, Modal, Replicate model-runtime: train and infer behind one interface, on any accelerator
Fine-tuning services OpenAI fine-tuning, Databricks Mosaic AI zetta training, with reinforcement learning from verifiable rewards
Model serving SageMaker endpoints, Baseten lake models: prediction behind keys, origins and traffic controls
A model and dataset hub Hugging Face Hub, Weights & Biases artifacts lake's hub, which the standard hub client talks to
A language-model gateway with metering OpenRouter, Portkey, LiteLLM lake's model gateway, with token metering
MCP servers and gateways Hosted MCP gateways Every capability of lake and zetta served as MCP, and an MCP client with per-tool approval
Speech-to-text Otter, AssemblyAI lake transcripts

Data

Instead of Such as Use
A cloud warehouse Snowflake, BigQuery, Redshift zetta: a replicated store, partitioned tables, SQL, distributed dataframes, compute next to the data
A lakehouse Databricks, Dremio zetta
Streaming and an event bus Confluent, Kinesis, Pub/Sub zetta topics, or Kafka as a lake service
Connectors Fivetran, Airbyte lake connections to the databases you already run
Pipelines and orchestration dbt, Airflow, Dagster zetta pipelines, written from intent or in Python, with a correctness gate
Workflow automation n8n, Zapier, Make zetta pipelines that import and run n8n workflows, and agents that run on schedules and from streams
Managed databases Neon, Supabase, PlanetScale, Aiven, RDS lake services: Postgres, TiDB, Cassandra, Valkey and zetta itself
Managed Kafka and ClickHouse Confluent Cloud, ClickHouse Cloud lake services
Small hosted SQL MotherDuck, Turso lake-sqlite, lake-duckdb and lake-polars
Full-text search Algolia, Elastic zetta's ranked search, and lake search indexes
Code search Sourcegraph liquid's code search
A vector database Pinecone, Weaviate Vector search, through OramaCore
BI and dashboards Tableau, Power BI, Looker Dashboards as custom apps, which the app builder can build for you

Developer platform

Instead of Such as Use
Version control Git, Git LFS, Perforce liquid
Code hosting and review GitHub, GitLab, Bitbucket lake's repositories
CI/CD GitHub Actions, GitLab CI, CircleCI, Jenkins liquid: build, test and verify on every write, deploys and previews from a change
Builds and remote execution Bazel, Nix, BuildBuddy, EngFlow liquid, which rebuilds only what changed
Image builds Docker Build Cloud, Depot lake builds
Package registries npm, PyPI, JFrog Artifactory, Sonatype Nexus, GitHub Packages lake's registry: containers, npm, Python and debug symbols
A container registry Docker Hub, GHCR, ECR, ACR lake's registry
Artifact storage Artifactory liquid and lake's store
Packaging packagecloud, fpm liquid's packages for Linux, containers and Windows
Supply-chain signing Sigstore services, Chainguard Signed provenance, bills of materials and a transparency log, in liquid and lake
Secret scanning GitGuardian liquid
An IDE VS Code, JetBrains, Cursor liquify

Hosting and infrastructure

Instead of Such as Use
App hosting Railway, Heroku, Render, Fly.io lake apps, deployed by liquid
Previews Vercel, Netlify A preview per change
Infrastructure as code Terraform, Pulumi Infrastructure as software (above)
Kubernetes fleet management Rancher, Spectro Cloud The operator: clusters as resources, always reconciled
Tunnels ngrok, Cloudflare Tunnel zetta-tunnel
Private networking and a service mesh Tailscale, Istio, Linkerd zetta-tunnel's mutual-TLS mesh
Ingress ingress-nginx, cloud load balancers zetta-tunnel's ingress
Observability Datadog, New Relic, Grafana Cloud Metrics, logs and dashboards in the platform
Status pages Atlassian Statuspage, Better Stack A status page as a resource
Object storage S3, GCS, Azure Blob lake's bucket stores

Identity, security and files

Instead of Such as Use
Workforce identity and single sign-on Okta, Microsoft Entra ID lake identity: single sign-on, provisioning, multi-factor and passkeys
Authentication for the apps you build Auth0, Clerk, Cognito, Firebase Auth lake's application authentication
Secrets and keys HashiCorp Vault, AWS KMS, Doppler lake secrets, sealed in each workspace
A private certificate authority Venafi, Smallstep, AWS Private CA lake's certificate authority
File storage and sharing Dropbox, Google Drive, Box lake drive, synced by liquid

What you still bring: the hardware or cloud you run it on, payments, team chat, documents and wikis, a content delivery network and notebooks.

The names above belong to their owners and are used only to say what each part stands in for.

How it fits together

How Orama Lake fits together: people, scripts and agents reach lake through one API served as REST, OpenAPI and MCP. lake holds AI Projects and the platform services. Under it are liquid, zetta, and the agents and models. The operator runs all of it as infrastructure as software, from one management cluster to dedicated leaf clusters.
lake Where you work. The workspace where you build, train and ship AI on your own data. Everything it can do is one API, served as REST, OpenAPI and MCP, so a person, a script and an agent all use the same thing.
zetta The engine underneath, in C++26. A cluster of equal peers with no leader. It stores and queries your data, searches it, trains machine-learning models on it, and explains every prediction they make.
liquid Differential source control, builds, packages and deploys in one program. Every write is captured and signed, and only what changed is ever rebuilt or redeployed. It imports from Git and exports back to it.
The operator Infrastructure as software. It runs all of it on your own Kubernetes clusters, creates the clusters, DNS and buckets a project needs, and keeps reconciling them while they run.
Agents and models The agent that builds agents, the one that builds apps, the one you ask questions, and the models they run on.

Ways to run it

Try it On a laptop, on a single-node k0s or k3s: no account and no credential Try it
Run it On one machine or a small cluster, with k0s and the operator Run it
Scale it On any Kubernetes cluster, with the operator's Helm chart Scale it
Air-gapped From one signed bundle, with nothing fetched from outside Air-gapped (a design)

Every way installs the versions in one release manifest, release.yaml.

For agents

Every Lake describes itself to an agent, at its own address. These are lake.live's:

llms.txt The agents' guide: what Lake does, which tools for which task, and the flows
llms-full.txt Every tool with its input schema
OpenAPI The same capabilities as OpenAPI 3.1, per region: Europe · United States
MCP https://<region>.lake.live/mcp, the same capabilities as tools
The lake skill A Claude skill for working in a Lake. It is in this repository, so a session opened here has it, and it links to the development skills in each component

A Lake you install serves all of them itself: /llms.txt, /llms-full.txt, /v1/openapi.json, /mcp and /skills/lake/SKILL.md.

Get the source

This repository is the entry point. It holds no product source: it pins every part of the platform at versions that work together.

git clone --recurse-submodules https://github.com/oramasearch/lake-platform.git

To take one part only:

git clone https://github.com/oramasearch/lake-platform.git
cd lake-platform
git submodule update --init modules/liquid-bridge
git -C modules/liquid-bridge submodule update --init modules/lake

Each component's own README says how to build and test it.

The components

Under modules/ What it groups
liquid-bridge liquid, lake and what runs beside them
zetta-bridge zetta, the tunnel, and the agents and models
orama-operator The operator
agent-experiments · model-runtime An agent and the model runtime
In liquid-bridge
Component What it is Path
lake The workspace, with agents, apps, repositories, search, file storage, sign-in, secrets and a container registry modules/liquid-bridge/modules/lake
liquid Differential source control, builds, packages and deploys modules/liquid-bridge/modules/liquid
liquify The IDE modules/liquid-bridge/modules/liquify
lake-sqlite, lake-duckdb, lake-polars lake's data sidecars modules/liquid-bridge/modules/lake-*
lake-builder Builds the images lake deploys modules/liquid-bridge/modules/lake-builder
app-runtime What the apps you build run on modules/liquid-bridge/modules/app-runtime
methodology-runtime What machine-learning methodologies run on modules/liquid-bridge/modules/methodology-runtime
k0s The small Kubernetes distribution the single-machine and air-gapped installs use. A fork, under its upstream Apache-2.0 license modules/liquid-bridge/modules/k0s
In zetta-bridge
Component What it is Path
zetta The engine modules/zetta-bridge/modules/zetta
zetta-tunnel Tunnels, a private mesh with mutual TLS, and ingress modules/zetta-bridge/modules/zetta-tunnel
agent-runtime What every agent runs on, including the ones you create modules/zetta-bridge/modules/agent-runtime
agent-creator Builds agents from a description modules/zetta-bridge/modules/agent-creator
agent-application Builds apps from a description and deploys them when you confirm modules/zetta-bridge/modules/agent-application
agent-ask-orama The assistant you ask questions modules/zetta-bridge/modules/agent-ask-orama
agent-project Builds and operates solutions and pipelines modules/zetta-bridge/modules/agent-project
agent-autosuggest Proposes what is worth building from your data modules/zetta-bridge/modules/agent-autosuggest
agent-eval-generator Writes the test cases agents are measured against modules/zetta-bridge/modules/agent-eval-generator
agent-project-corpus, agent-autosuggest-corpus The agents' training corpora modules/zetta-bridge/modules/agent-*-corpus
base-agent-0.6b The base model the agents run on modules/zetta-bridge/modules/base-agent-0.6b

The C++ libraries the engine vendors (the CRDT library, the full-text search library, the networking libraries) are submodules of the components that use them, so they arrive with a recursive clone.

How the pins work

  • This repository pins each bridge, and each bridge pins its components.
  • The pins move together. A commit here is one set of versions that work with each other.
  • To see what is pinned: git submodule status --recursive.

A foundation to build on

The software that lasts tends to be built on ground that's solid, open and impossible to take away. When the foundation is free, people spend their time on what only they can build.

We've laid the floor: the engine for your data, the source control, the workspace, the agents, the models, and the operator that runs them. What goes on top is yours.

Professional Services Available

Metis is our professional services program. If you'd like some help designing or launching your AI and intelligence, we'd love to chat (even if you'd just like to say hello). https://orama.com/journey

Contribute

Questions, ideas and pull requests are welcome. CONTRIBUTING.md says how to build a component and send a change (contributors sign the Contributor License Agreement once). GOVERNANCE.md says how decisions are made and how to become a maintainer, and ROADMAP.md what comes next. Everyone follows the code of conduct. The names and logos are covered by TRADEMARKS.md.

License

MIT. Forks of third-party code keep their upstream licenses, and model weights carry their base model's license; THIRD_PARTY_LICENSES says where each component's notices are. The names and logos are trademarks and are not covered by the license: see TRADEMARKS.md. Contributions are welcome under the Contributor License Agreement; see CONTRIBUTING.md.

Free, sovereign AI, for everyone.

About

Orama Lake: the sovereign AI stack. Use AI to easily Design, Train, and Ship your own custom models, agents, workflows, and warehouses to prod in minutes. MIT-licensed AI infrastructure that runs everywhere. Free, sovereign AI, for everyone.

Resources

Code of conduct

Contributing

Security policy

Stars

8 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages