Coinbase published a three-part series this month, Owning Intelligence, on a fraud agent for its fiat-to-crypto onramp. They placed a language model behind their existing model and rules as a second screen, one that could block what the first screen passed and could never reverse a block. They built a fixed benchmark of past cases and measured every model version against it. Then they post-trained an open-weight model of nine billion parameters on their own confirmed fraud outcomes.
Coinbase reports that the post-trained model beat Claude Opus 4.5 on precision, recall and F1, answered in less than half the time, and cost under $100 to train on a single GPU. They also report that newer releases of the frontier models scored lower on their benchmark than the versions before them. We could only read the series in a browser, so the figures here are Coinbase's own, as summarised by its CEO.
We read it closely because our customers ask the same question in different words: can the model learn from our data, stay with us, and get better the longer it runs? The answer is yes. The way we are doing it differs from Coinbase's in one place, and that place matters.
What runs today
ATROSA's agent writes AML and fraud detection rules as Python code from a customer's exports. Each rule runs in a sandbox on the data, is scored without labelled cases, and is rewritten, up to 100 times in a run. On one remittance operator's data, 51 runs produced 2,037 rule versions, of which 12 were kept. The kept rules then run on new data as plain code, with a hash on each file, and no model is called at the moment a decision is made.
That loop has the same shape as the environment Coinbase had to build before it could train anything. The state is the customer's schema and the scores so far, the action is a rule, and the reward is the score. Coinbase built theirs for the purpose. Ours runs in production, and every run leaves behind the examples a model would be trained on.
The model writes, the code decides
Coinbase fine-tuned the decider. Their model reads a transaction sequence and returns a risk level, on every transaction, at the moment of the decision. We fine-tune the author. The model's output is a rule, the rule is reviewed by the customer's engineers, and the rule makes the live call.
That difference is the governance story. A fine-tuned decider has to be explained to an examiner as a model. A fine-tuned author produces code that can be read, replayed over any past month, and signed off before it runs. The model never touches a live transaction, so a model that improves changes nothing about how a decision is audited.
One model per customer
The plan is one model per customer, trained on that customer's runs alone, kept inside their environment, and used only to write rules. The base is an open-weight model of the same class Coinbase used. It learns the things a general model has to rediscover on every run: what the columns mean, which joins across the customer's sources carry signal, what has been kept before. We expect a kept rule in a handful of iterations, where today it takes fifty or more.
Each model is trained on one customer's data and on that alone. It is that customer's asset, and it compounds the longer the loop runs.
What has to be true first
Coinbase's reward was 813 confirmed fraud cases. A score that can be computed without labels is useful for writing rules and risky as a training signal on its own, because a model trained against it learns to please the score. The order of work follows from that risk.
- A fixed benchmark of past runs, so that every model, ours or a vendor's, is measured on the same cases. Coinbase's finding that newer models regressed is the reason this comes first.
- Supervised fine-tuning on the rules that scored and were kept. It reuses what is already on disk and shows whether the thesis holds.
- Confirmed outcomes wired into the score: cases the customer has checked by hand, dispositions from review, chargebacks.
- Reinforcement learning, once the reward is partly grounded in those outcomes.
- The model itself, shipped to each platform customer as their own.
We are doing these in order, and the benchmark results will be published when they exist. Until the fine-tuned model beats the general one on that benchmark, the general model keeps writing the rules.
When it does, a platform customer gets a model trained on their data alone, running on their hardware, writing rules their engineers read, with the live decision still made by code. That is what owning intelligence should mean for a company that answers to an examiner.
