The prompt was ordinary:
"From the abalone data, build a regression model to predict age from physical measurements."
Abalone age is normally found by cutting the shell open, staining it, and counting growth rings under a microscope — one ring roughly per season. It works, but it's slow and it kills the animal to measure it. The dataset exists because researchers wanted to know whether cheaper, non-destructive measurements — shell length, weight, diameter — could substitute. The schema VerbaGPT pulled in states the target plainly: age_years = rings + 1.5. The regression task is, literally, trying to predict a ring count without counting rings.
VerbaGPT built a scikit-learn pipeline: seven numeric measurements (length, diameter, height, and four weight variants) plus one-hot-encoded sex (male/female/infant), a standard linear regression, an 80/20 train-test split. Nothing exotic — the kind of first-pass model you'd sketch on a whiteboard before reaching for anything fancier.
| Metric | Value |
|---|---|
| R² | 0.5482 |
| RMSE | 2.2116 years |
Physical measurements explain about 55% of the variance in age. The other 45% isn't in the data at all — it's whatever makes two abalones of identical size a couple of years apart in age: growth rate, environment, genetics. And an average miss of 2.2 years is a real margin on an animal that mostly lives into its teens. Good enough to screen a haul without a microscope; not good enough to replace one. That gap is exactly why marine biologists still count rings by hand.
Reading the full execution trace behind this answer (not just the final chat response) turns up something worth being straightforward about. Immediately after writing the code — before it had actually run — the model wrote a line of commentary predicting its own result:
"The model achieved an R² score of 0.5248 and a Root Mean Squared Error (RMSE) of 2.1532..."
Then the code executed, and the real printed output was:
R2 Score: 0.5482 · RMSE: 2.2116
Different numbers — close, digit-shuffled, the kind of small drift you'd only catch by diffing the two. The model guessed at its own outcome before seeing it, the way a person might say "should come out to around 0.52" before actually running the numbers. Ordinarily that guess would just be a footnote. The reason it matters here is what happened next: the number that actually reached the chat window was 0.5482 — the real one, not the guess.
That's not a review step catching an error after the fact. It's simpler than that: the code's own last line was final_answer(f"...R2 score of {r2:.4f}...") — a Python f-string, formatted from the live r2 variable computed two lines earlier. Whatever the model said out loud a moment before, the string the user sees is assembled from the actual number sitting in memory. The guess and the answer are structurally different things, produced by different steps, and only one of them is wired to what actually ran.
Under the hood, this one query resolved through two separate models before either line of commentary was written: schema resolution ran on gpt-oss-120b (1.07s), code generation on Gemma 4 31b (both open-weight, both hosted on Cerebras), against the abalone table in an Azure SQL demo database. Round trip, prompt to answer: 8.5 seconds — including a model that briefly disagreed with itself along the way.
Data source: the Abalone dataset (UCI Machine Learning Repository), 4,177 samples — one of VerbaGPT's built-in sample datasources.
Ask your own question about this dataset → The ML Demo datasource is live and open — no signup required for a few questions.