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 prodRuns in Claude Code, with the lake skill that ships in this repository.
Install · Why · What you get · AI Projects · Infrastructure as software · Batteries included · Use Orama Lake instead of · How it fits · For agents · Get the source · The components
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.
| 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/.
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.
|
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. |
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. |
|
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. |
From supercomputers to embedded devices, on any accelerator, any cloud and any architecture. |
|
Training, inference and agents all spread across a cluster, with agents working as swarms and as teams. |
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. |
|
Models run on hardware you already own, every token is metered, and the limits are yours to set. |
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. |
|
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. |
The controls an audit asks for are part of the stack: signed history, access rules, audit trails, secrets and keys. |
|
A project holds many models, workflows, agents, databases, storage and apps, all working together for one purpose. |
Spin up any infrastructure on the fly: clusters, DNS, buckets. It is always reconciling, and you can change it while it runs. |
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.
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.
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 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.
| 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 |
| 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 |
| 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 |
| 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 |
| 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.
| 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. |
| 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.
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.
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.gitTo 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/lakeEach component's own README says how to build and test it.
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.
- 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.
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.
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
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.
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.