Reinforcement learning is an old idea: you improve at a trade by practicing it, and by knowing how each attempt turned out. Models improve the same way. Everything you'd want one to do runs through its environment, the information it can reach and the steps it can carry out. We build the environment to order around your process, and the verification spine to go along with it. Better work gets done, and that work is verified.
The recent jumps in model capability came from environments. Here is a run through one of ours, condensed:
| step 1 | frame the experiment | ✓ plan recorded before launch |
| step 2 | provision compute | ✓ pod heartbeat |
| step 3 | run the experiment | ✗ pod died mid-run |
| → resumed at step 3, no work lost, ✓ | ||
| step 4 | score the result | ✓ metric computed against the plan |
| step 5 | settle the cost | ✓ reconciled against the provider invoice |
| done | record appended · next experiment planned | |
from rockie, the environment we run in public at rockielab.com. yours has your steps and your checks.
Every step gets the strongest check it allows: computed by code where possible, a trained classifier where not, a calibrated judge where the call needs taste. A failed run resumes at the step that failed. Every scored run joins the record.
Engagements run in three stages. Most customers start at the first and decide later how far to go; nothing built at an earlier stage gets thrown away at a later one.
We scope one process, build its environment, and hand it over doing the job, on a frontier model to start. The step map and the first checks get built here; the later stages reuse both.
The full set of checks is in place and every run is logged against them. Compliance gets an audit trail and postmortems start from a step number. Reliability turns into a percentage you can read off the run history.
An environment with checks is a training ground. We run an open-source model through it at volume and train against the scores — reinforcement learning on your own process. The result is a model tuned to the work, at a fraction of frontier API cost per run, that no one can reprice or deprecate out from under you.
The scored run records are the durable asset: plain data with no vendor attached. When a stronger open base model ships, the same environment trains its replacement.
A call. You describe the process and the outcome you need from it. If an environment is the wrong tool for the job, we say so on the call.
About a week inside your systems, finding where checks can attach and what the environment has to touch. Discovery runs under your access model; we keep the step map and none of your data. You get a written proposal: the end goal, the work packages, the price.
The environment and its checks, built and then exercised against real runs of your process before we call it done.
Handoff, on your infrastructure or ours, with a retainer for working sessions, maintenance, and the next stage when you want it.
Pebble publishes its own research on matrix-valued state and measurable reasoning in language models. Findings go out as falsifiable notes with code and eval data. Instrument bugs are disclosed, and negative results stay published.
Rockie is an RL environment we maintain for the public good. It runs experiment loops for academic groups doing HPC research, including ML. The system behind it is written up in our white paper, Scaling Experimentation, on making the full experiment loop run as software.
Rockie is tuned for scientific discovery, and we keep it public because an environment improves with every kind of work that runs through it. The hope is that the models people run in there leave human knowledge further along than they found it. An account takes a minute at rockielab.com.