Promptable brains

A promptable brain learns to honor constraints you set at the moment you ask it a question. You don’t retrain. You don’t fork. You toggle a chip on the Brain page, and the same trained brain answers differently — because the chip tells it something only you know.

The easiest way to feel it: fork the PFNs · Promptable template from the marketplace.

Five-minute walkthrough

1. Start from the template

In the studio’s project picker, choose PFNs · Promptable (steerable at inference). It lands as a regular project with:

A prior that already declares one axis (monotonicity — does the input drive the output one direction, or both?)
A model spec that has the tag pathway wired in
A training run pre-configured to teach the brain to honor that axis

You can inspect any of these in developer mode, but you don’t have to.

2. Hit ▶ Run training

About 10 minutes on CPU. Slightly longer than the standard PFNs reference because, alongside the main brain, a small detector is also trained. The detector’s job is to look at your data later and propose what each chip should be set to — so you don’t start from a blank form.

3. Open the Brain page

After training completes, the Brain page renders a new card:

 Constraints
 Toggle what you know about your data. The brain re-predicts honoring the chips you set.

   monotonicity   [ positive ]  [ negative ]  [ mixed ]
                       ▲ pre-selected by the detector

The chips:

positive — “as the input goes up, the output goes up”
negative — “as the input goes up, the output goes down”
mixed — “no consistent direction”

When the page first loads, the auto-test runs and the detector pre-fills one chip based on the sample it just saw. You can confirm it, override it, or unset it (click the active chip to clear).

4. Toggle a chip — the forecast moves live

Click a different chip. The “Test your brain” scoreboard reruns on the same data with the new tag. Predictions update in place. That’s the demo:

Same context. Same brain. Different chip. Different answer.

What’s not happening: no retraining, no new sampling, no model swap.

What is happening: the trained brain learned, during training, what each tag value means — and at inference it uses your chip as one more input alongside the data.

Why this is different from a prompt

LLMs take prompts. Prompts are unstructured natural language; they sometimes work, sometimes don’t, and you have no way to know which.

A chip is structured. It maps to a specific property of the model’s prior that was sampled across during training. When you toggle it, the model provably shifts (see the Axis honoring field in the run results — that’s the divergence the model produces between two opposite chip values on the same context).

If honoring is near zero, the chip is broken — the model trained but didn’t learn to use the tag. The number in the run results catches that for you. Above ~0.05 mean L2 you can usually see the change with your eyes; above 0.10 it’s unmissable.

What this template ships vs the standard PFNs reference

	PFNs · reference	PFNs · Promptable
Closed-form benchmark	tight match to the analytic posterior	slightly looser (trains on a tag-mixture)
Brain page chips	none	Constraints panel + detector pre-fill
Run results carry	loss curve, RMSE	+ `axis_honoring`, + companion detector
Best for	reproducing the paper exactly	demoing steerability, building on top

Both ship the same Müller 2022 Bayesian-linear prior — the difference is the model spec and the training flag.

Authoring your own promptable brain

The marketplace template is the friendliest path. If you want to add a different axis (lag length, feedback structure, sensor reliability), you’re in developer-mode territory:

Open Edit Prior. The Promptable axes section lets you declare a new axis with a name, kind (categorical / range / boolean), value list, and a Python hook that narrows the prior when the tag is set.
Make sure your model spec uses tag_aware_transformer_encoder instead of transformer_encoder — the wizard doesn’t auto-swap yet, so this is a manual edit in the model YAML.
Set promptable_training: true in your run hyperparams.

See Developer mode for the file shapes.

What’s still rough

The wizard doesn’t auto-build promptable brains yet. Basic-mode users fork the template (works great); building from a fresh capability picker requires developer mode for now.
Honoring scores below ~0.10 produce a chip toggle the user can’t see. Training longer or on a bigger model fixes this — the marketplace template trades runtime for steerability you can demo at 16k steps.
One axis per template, today. Multi-axis training works (the framework handles arbitrary axis combinations) but no shipped template uses more than one.

Capabilities reference — what each brain can do
The brain page — where the Constraints panel lives
Marketplace — how forking works
Roadmap — where promptable brains fit in the broader plan