Zetta · the platform

One platform for everything that runs on your data.

Metis is built on Zetta

Metis is the Enterprise Intelligence OS. Zetta is its software side: one distributed platform, one binary, that scales from a single node to a cluster and runs where your data is.

Batteries Included

Six instruments, one platform.

Zetta holds the data, runs the pipelines, trains the models, serves the agents, and renders the dashboards, on the same nodes. Nothing has to leave the platform to become intelligence, and nothing on it can outrun the data it can reach.

  1. 01

    Dashboards

    What happened and why, over conformed data with one definition per metric, for the decisions a team actually makes. The descriptive and diagnostic tiers of the operating system.

  2. 02

    Pipelines

    Intent compiled into a typed pipeline, connect, clean, model, index, serve, verified before it runs. The pipeline is how raw capture becomes conformed, governed, consumption-ready data.

  3. 03

    Warehouses

    The store, in whichever of three ways you choose: Zetta as the store with your warehouses connected as sources, Zetta running over the warehouse you already have, or Zetta becoming the store over time.

  4. 04

    Applications

    The applications an enterprise runs on its intelligence, and the applications that create the data a decision lacks: capture at the point of decision, workflow applications in place of spreadsheets, extractors, experiments, and collectors.

  5. 05

    Agents

    Software that plans and acts across systems, under per-action permission and full provenance, with every action recorded as a decision. The tier with the least tolerance for missing data, because its failure is an action, not a belief.

  6. 06

    Models and model training

    Models trained natively on your data, inside your environment, with calibrated confidence and explained drivers. The predictive tier, and the engine underneath grounded answers and agents.

Two sides

Software, and how it is executed.

The software side of Metis is Zetta. The execution side is forward-deployed engineering and the theory the operating system is built on. Neither works without the other.

The software side: Zetta

  • One binary, one cluster

    A single native executable is a node. Nodes join into one replicated, self-healing cluster that spans a laptop, a data center, and any cloud.

  • Compute next to the data

    Pipelines, training, indexing, and serving run on the nodes that hold the data, rather than pulling it out to be processed elsewhere.

  • Verified before production

    Schema, leakage, point-in-time, and entity-resolution checks gate every pipeline. A failed check blocks it and says why.

  • Driven programmatically, observed visually

    Every action a person can take in Orama Studio is a tool an agent can call, identically. The surface exists to make the platform's work legible.

  • Governed by construction

    Identity, scoped keys, consent for anything that touches a cloud provider, and an append-only audit of every call, allow and deny alike.

The execution side: forward-deployed

  • Decisions first

    Inventory the decisions that matter, with their owners, alternatives, and the metric the unit already reports.

  • Data availability, scored

    Each decision's data scored on ten dimensions against the instrument it needs, with evidence, and the weakest gap named.

  • Raise what is short

    Connect what exists, conform and govern it, and create the data that was never captured, inside your tools.

  • Run what the data can carry

    Reports, models, grounded answers, and agents, one decision at a time, each admitted when its data meets the bar.

  • Measure outcomes and returns

    Every decision logged with its expectation; outcomes measured at the horizon; returns stated in your metric against a signed baseline.

Orama Studio is the surface over Zetta. OramaJS is the open-source search library the team started from.

Where your data lives

Meets your data where it is.

All three are supported, chosen per customer with your platform team. The method is the same in each; what differs is who owns the store and how currency and access are measured.

Zetta as the store

Your warehouses, databases, and applications connect as sources. Zetta holds the intelligence data and runs everything above it. Scoped with sales.

Sales-led

Zetta over your warehouse

Your warehouse remains the store. Zetta runs pipelines, models, and agents over the tables where they sit, without copying them. Scoped with sales.

Sales-led

Zetta becomes the store

Start in either of the first two and let Zetta take over the store progressively, at your pace, as the warehouse's job moves onto the platform. Scoped with sales.

Sales-led

Zetta runs as one node or a cluster, in your cloud, on-prem, or dedicated.

Grounded in reality

Why an operating system, and not another model.

You cannot have AI, or intelligence, without data availability. Everything on this page exists to make that sentence operational.

Data availability

Does the data a decision needs exist, can it be reached and lawfully used, is it true, current, and understood, and is it fit for the instrument. Ten dimensions, scored per decision, combined as a weakest link.

Decisions

The unit everything hangs off. Metis is decision-driven, not data-driven: availability is scored against a decision, never in the abstract, and an instrument is run for a decision only when its data can carry it.

Outcomes

Every decision is logged with what was expected. Outcomes are measured at the horizon and calibrated over many decisions, so skill is separated from luck.

Returns

Return on investment (ROI), stated in the unit's own metric against a signed baseline: what was invested, how far availability rose, which instruments that made possible, and what came back.

Every figure we publish is a verified claim in our registry. Where a number is not verified, we state the method and publish nothing.

See it on your own decisions

Bring the decisions that matter and the data you have. We score availability first, then build what the data can carry.