I work on

The open-source MLOps platform

Where engineers and agents work together.

You set the objective. Agents run the experiments. Every run is tracked and reproducible, one click from production, and monitored once it's there.

work alongside agentsevery run trackedone portable artifactdeploys in your networkmonitored in productionwork alongside agentsdeploys in your network

The Problem:

Everyone wants agents doing ML work. Nobody has a clear structure.

The capability isn't the gap. Agents already write the training code, run the experiments, and can carry a model the whole way to production.

What's missing is the structure around that — where runs get tracked, how they get compared, explained, reproduced, and productionized. So every team improvises: different ways of working, different tools, wired to agents differently each time.

It holds up until you have to explain a result, rerun it, or hand it to someone else.

The Solution:

We have a structure. It is called LUML.

Five steps, from your first instruction to a model running in production.

0102030405
STEP 01 / 05Work with agents, side by sideYou drive a coding agent from the terminal you already use. What it produces appears beside you as work you can look at: experiments, metrics, models. Whether you trained it or the agent did, it is captured the same way.
STEP 02 / 05The agents get better at your domainNone of that session is thrown away. What worked, what you overruled, and the details specific to your domain get consolidated into your team's context — so the next session starts from the knowledge you already provided, instead of from scratch.
STEP 03 / 05Hand over the objectiveOnce the context holds enough, you can stop supervising each run and state a goal instead. Prisma forks it into parallel branches, runs each in its own git worktree and proposes the next direction. Weak branches are pruned, a fixed metric defines the winner, and the winning model comes back to you for review.
STEP 04 / 05The winning model folds into one artifactWeights, metadata, dependencies and preprocessing fold into a single self-contained .luml artifact. The registry versions it and links it back to the exact experiment that produced it. Nothing about how it was made is left behind on a laptop.
STEP 05 / 05Deployed and monitoredA service you host inside your own network reaches out, pulls the artifact and serves it, so nothing has to reach in. Monitoring sits on the same machine, watching drift, data quality and health where the model actually runs.
churn_clf · v7sha256 a41f…9c2e
NEXT OBJECTIVEretrain on window w41
SERVING · YOUR COMPUTE214req/minp95 11 ms
PSI DRIFT · SEGMENT EU0.061outside tolerance

The Solution:

We have a structure. It is called LUML.

Five steps, from your first instruction to a model running in production.

0102030405

STEP 01 / 05

Work with agents, side by side

You drive a coding agent from the terminal you already use. What it produces appears beside you as work you can look at: experiments, metrics, models. Whether you trained it or the agent did, it is captured the same way.

churn_clf
improve recall on churn_clf
·edit train.py · class_weight
·edit train.py · threshold
python train.py --focal-loss
·edit train.py · sweep gamma
EVERY EXPERIMENT LANDS IN THE WORKSPACE

STEP 02 / 05

The agents get better at your domain

None of that session is thrown away. What worked, what you overruled, and the details specific to your domain get consolidated into your team's context — so the next session starts from the knowledge you already provided, instead of from scratch.

SESSION 01exp_0217 → exp_0221
three turns out of twelve were worth keeping

STEP 03 / 05

Hand over the objective

Once the context holds enough, you can stop supervising each run and state a goal instead. Prisma forks it into parallel branches, runs each in its own git worktree and proposes the next direction. Weak branches are pruned, a fixed metric defines the winner, and the winning model comes back to you for review.

AUTONOMOUS SEARCHchurn_clf
context and objective go to Prisma, then you walk away
12 attempts3 pruned4 generations

STEP 04 / 05

The winning model folds into one artifact

Weights, metadata, dependencies and preprocessing fold into a single self-contained .luml artifact. The registry versions it and links it back to the exact experiment that produced it. Nothing about how it was made is left behind on a laptop.

STEP 05 / 05

Deployed and monitored

A service you host inside your own network reaches out, pulls the artifact and serves it, so nothing has to reach in. Monitoring sits on the same machine, watching drift, data quality and health where the model actually runs.

churn_clf · v7sha256 a41f…9c2e
NEXT OBJECTIVEretrain on window w41
SERVING · YOUR COMPUTE214req/minp95 11 ms
PSI DRIFT · SEGMENT EU0.061outside tolerance
PSI DRIFT0.061segment euYOUR COMPUTE214req/minNEXT OBJECTIVEretrain onwindow w41

Meet the Team

We built the tool we always needed

We're data scientists and engineers who've built AI systems end-to-end at L'Oréal · Bitpanda · SCCH — across startups and large-scale environments.

Iryna
IrynaCEO
Oleh
OlehCTO
Kate
KateBackend Developer
Olha
OlhaData Scientist
Valera
ValeraFrontend Developer
Anna
AnnaUI/UX Designer
Nikita
NikitaTechnical Advisor

FAQ

Frequently
asked
questions

The path from first experiment to production, for humans and agents on one platform: experiment tracking with traces and evals, autonomous research loops, and a registry with deployments and monitoring on your own infrastructure.

One platform for the entire AI lifecycle.
Open-source and free to start.