Runix. The operating system for enterprise AI.
Most teams start at the gateway: one OpenAI-compatible endpoint in front of every model provider, available today. Beneath it, the file system, data and model layers are in early access; the agents on top are in development. Use one layer, or run the whole stack.
Runix Lab · the AI operating system
Five layers, seven products
05AgentsDomain agents, and the harnesses that run them
04GatewayOne way in to every model
03ModelsOpen-weight models, tuned and served
02DataDomain data, cleaned for training and evaluation
01InfrastructureStorage that keeps GPUs fed
00Compute & energyYours, not ours
GPUs, power and cloud capacity in your own account, with the object storage and Kubernetes you already run. The stack runs on them and replaces none of them.
Works with the stack you already run
- OpenAI SDK
- LangChain
- LlamaIndex
- Vercel AI SDK
- PyTorch
- Spark
- Flink
- Kubernetes
- Amazon S3
- MinIO
Why an operating system, and why now
The stack is a bet about where the hard part of AI moved: from the demo to the production run, and from one vendor to five.
Why now
Three things changed at once
Agents turned one user action into many model calls, so who holds the keys, what each key may spend and what happens when a provider degrades became production questions rather than operational details.
Open-weight models became good enough for narrow, repeated tasks, so the data a team owns and the GPUs it already rents started to matter more than which vendor it calls. And procurement caught up: a legal review now asks where prompts go before an engineer asks whether the model works.
The bet
These layers belong together, the way Unix's did
The file system, the data, the models, the gateway and the agents are bought today from five vendors under five contracts, with scripts for glue. Runix draws them once and builds each as a product a team can adopt on its own.
The company that keeps the layers honest with each other, under one contract, one call interface and the customer's own storage and compute, earns the position an operating system has: everything above it can change without touching anything beneath.
How we are doing it
In the order the evidence allows
The gateway is available today. The file system, the data and the models are in early access. The agents are in development. Nothing on this site is marked further along than it is, and a build check fails the site if any page disagrees with the product list.
What is in writing is linked, not promised: data terms, contracting, the price catalogue and the roadmap. Three of the tools we built to run a gateway are open source, including a benchmark you can run against us.
How the layers connect
Two paths run through the stack. Requests go down through one endpoint; data comes up into training. Each product hands off to its neighbours, and each works on its own.
The request path, top down
Runix Code · Comic · your agentsRunix RouterHosted providersorA model tuned by Runix Models
One OpenAI-compatible API in front of every model. Keys, quotas and failover sit beneath it, so the application never learns which provider answered, or whether the answer came from a model of your own.
The data path, bottom up
Your bucket · Runix FSRunix PipelineRunix DataRunix Models
Raw material is read through the file system, cleaned in stages you can inspect, given each domain's rules, and lands as training and evaluation sets for a model tuned to your task and served on dedicated capacity.
What compounds is not your data: content sent through Router is never used to train anything. What compounds is the contract, the interface and the path. One MSA and DPA cover every layer. A model tuned by Runix Models answers at the same endpoint as the hosted providers, so moving a narrow, high-volume task to a model of your own is a routing change rather than a migration. And the bucket Runix FS mounts is the one Runix Data reads from and Runix Models trains on.
Seven products, one stack
Each product sits in one layer of the stack and works on its own. The statuses are literal: Router is available, a production service with accounts opened by our team; Models, Data and FS are in early access; Pipeline, Code and Comic are in development. Early access means a team can be onboarded today, and the qualifier on each tile says what that looks like: a deployment for FS, a scoped engagement for Data and Models. In development means it cannot be bought yet.
Layer 05
Agents
Where AI does the work: independent agents for a domain, and the harnesses that run them. Two domains far apart on purpose: Code is judged by a test suite, Comic by an audience. The layer by domain.
Runix Code
An AI coding agent grounded in your repository, where every change lands as a reviewable diff.
- Codebase-aware help in the editor and the terminal
- Multi-file tasks checked against your test suite
- Seats, per-key limits and usage by developer
Runix Comic
An end-to-end studio for AI comic dramas, from the first script to a published episode.
- Scripts, episode plans and consistent characters
- Storyboards, styled panels, motion and voice
- Vertical cuts and full episodes from one project
Layer 04
Gateway
How every application reaches every model provider: one endpoint, with the controls around it.
Layer 03
Models
Open-weight models tuned to one task, for when a general-purpose model is not the answer.
Layer 02
Data
What models learn from and are measured against, cleaned with the judgement each domain needs.
Runix Data New
Training and evaluation data in six domains, code first, then finance, cybersecurity, legal, embodied AI and AI for Science: cleaned, verified and delivered with a quality report.
- Code tasks verified by running their tests
- Provenance and licence recorded for every record
- Personal data masked, failing closed
Runix Pipeline
The tooling behind Runix Data: ingest, clean, structure, mask, report and deliver, with every stage auditable.
- Deduplication at exact, near and semantic levels
- Extraction into your schema that fails loudly
- A quality report with every delivery
Layer 01
Infrastructure
The file system that keeps GPUs fed from the object storage you already run.
Built for the team that calls
Six kinds of team, the problem each usually arrives with, and the product to start with. Every product is also sold on its own. All solutions.
For platform teams
One endpoint for every model, with the controls your team owns
For the team that owns the integration between the company's products and the model providers. Runix Router puts one OpenAI-compatible endpoint in front of every provider, with key custody, per-key limits and usage by key beneath it. Where training or inference data lives in object storage, Runix FS gives the GPUs a file system over the bucket.
- Start: Runix Router
- Runix FS
For model teams
Data you can audit, a model you can measure
For teams that train or tune models and have to show where the data came from and whether the result beats what they run today. Runix Data builds training and evaluation sets with provenance per record. Runix Models fine-tunes open-weight models and serves them single-tenant. Runix FS reads it all from the bucket you already have.
- Start: Runix Data
- Runix Pipeline
- Runix Models
- Runix FS
For engineering organisations
AI coding rolled out, not smuggled in
For organisations adopting AI coding across many developers and many repositories, where a pile of personal accounts and no visibility is the current state. Runix Code, in development, is being built so every change lands as a reviewable diff, with seats, per-key limits and attribution by developer. Runix Router gives the model calls one policy and one bill.
- Start: Runix Code
- Runix Router
For studios and creators
A studio for comic dramas, from script to episode
For studios and independent creators making serialised visual stories, comic dramas in particular, where the work is the whole production line and not a single picture. Runix Comic, in development, is being built around pre-production, production and publishing, as an independent agent with its own harness. Runix Router is optional in front of its model calls.
- Start: Runix Comic
- Runix Router
For regulated industries
Written answers for the review that never ends
For finance, legal and security teams that have to answer a reviewer before anything carries traffic. Runix Router puts the data terms, the contracting entity and the service level in writing. Runix Data applies domain rules for finance, legal and cybersecurity data. Runix Models serves a model single-tenant, in your cloud account, trained on your data and nothing else.
- Start: Runix Router
- Runix Data
- Runix Models
For research labs
Datasets in the bucket, GPUs that stop waiting
For AI for Science and embodied AI groups with datasets in object storage and records that need domain judgement before a model learns from them. Runix FS mounts the bucket as a file system, cached in front of the GPUs. Runix Data applies its rules for antibody, protein and embodied AI records. Runix Models tunes and serves open-weight models.
- Start: Runix FS
- Runix Data
- Runix Models
What we put in writing
Two things stall AI rollouts: the provider that fails at 3am, and the review that never ends. The products handle the first. This is what we put in writing for the second.
You own your content
Prompts, outputs and files you send through Runix are yours. We do not use your content to train models, other than a model you ask Runix Models to train on it, and we do not sell it.
Content vs. metadata
We keep operational metadata, such as usage counts and error codes, to run billing, reliability and support. The Privacy Policy says what is kept and for how long.
Paperwork on request
MSA and DPA reviewed per engagement. Refund, cancellation and acceptable-use policies are published in full.
Stated plainly
We do not claim certifications we have not earned. The Security page lists the controls that are actually in place.
Where this is, and what comes next
Drawn from the same product definitions as the stack above. No dates are published; a status changes when the thing changes.
Now · available and early access
4 products a team can use today
- Runix RouterOne compliant endpoint for every model
- Runix ModelsFine-tune and serve open-weight models
- Runix DataDomain data for training and evaluation
- Runix FSAI-native file system on your object storage
Building · in development
3 products with waitlists and design partners
- Runix CodeAn independent coding agent, reviewable in your repository
- Runix ComicAn independent agent for comic dramas, script to episode
- Runix PipelineThe tooling that makes data model-ready
Next · at general availability
What general availability adds
- A complete API reference
- A published service level for Router
- Self-serve signup and checkout
Writing, by layer
Engineering notes on the mechanics behind each layer, dated and signed. All posts.
Layer 05
Agents
- What is a coding agent? From autocomplete to pull requests
- The harness: what actually runs an AI agent
- Reviewable by default: why an agent's changes should land as diffs
Layer 04
Gateway
- Turning an LLM bill into a policy: budgets per team and per feature
- How to read an LLM price list
- Auto routing versus a pinned model id: choosing an LLM routing policy
Layer 03
Models
- Single-tenant model serving explained: what a dedicated LLM inference endpoint changes
- LoRA vs QLoRA vs full fine-tuning: what each one changes in the weights
- How to read an open-weight model licence before you fine-tune it
Layer 02
Data
- What a data quality report should contain, and how to read one sceptically
- Training data provenance: what every record should carry, and why a README is not proof
- Split by source, not by row: how benchmark contamination reaches your own evaluation set
Run AI on an operating system, not a pile of scripts
Tell us your use case and expected volume. A real person replies within one business day with a concrete plan and pricing.
Already building with us? Contact support