This page is the template for Vmax tools. Build your own with the create-vmax-tools-page skill: it gives you this shell, the sidebar, and every form primitive shown below. The controls on this page decide who can open a published paper, how it can be reused, and what ships alongside it. Drafts are never affected.
Use <FormTextCompare /> to show an edit as a unified diff. Removed lines wash var(--theme-diff-delete-wash), added lines wash var(--theme-diff-insert-wash), and every row snaps to one var(--theme-grid-block). The diff stays inside the 768px column and scrolls sideways when a line runs long.
<FormTextCompareSideBySide /> is the split view. Before sits on the left, after on the right, and a hatched blank fills any line without a match. Reach for it when readers need both versions in full.
The same component reads well on code. Here a recursive factorial becomes the triangular numbers, so only the two edited lines change color.
Use <FormCode /> for source the way a run carries it. A dependency-free tokenizer colors python, json, shell, and log through the shared var(--theme-graph-option-*) palette, mixed toward var(--theme-text) so every token lands legible on both themes. Same measured rows as the diffs: a numbered gutter, one var(--theme-grid-block) per line, sideways scroll past the 768px column.
The shell language covers the commands a page tells its reader to run (set copyable on those and a copy control joins the caption line), and log picks the verdict words out of a verifier's output: PASSED reads var(--theme-diff-insert), FAILED and ERROR read var(--theme-diff-delete).
Use <FormJSONExplorer /> to let readers walk a JSON payload. Every object and array folds with the + / - toggles, so a large record stays scannable.
The small controls and text marks every tools page is built from. <FormInput /> is the text field. The glass square on the right submits, Enter submits too, and the attached flag docks it flush beneath a <WebTerminalWindow />.
<FormTextArea /> is the multiline sibling on the same hairline surface: the shape a prompt input takes. It auto-grows to fit what you type, reflows on resize, and opens sized to its placeholder, so a worked Example: reads in full. Enter inserts a newline; Cmd or Ctrl with Enter submits, as does the glass square pinned to the bottom-right.
<Checkbox /> is the toggle. A native input hides behind the square figure, so it stays accessible while the mark matches the kit. Control it with value and onChange.
<FormList />is the list. Unordered rows take the kit's outline square as their bullet, and wrapped lines keep a hanging indent.
var(--theme-grid-block); nothing is measured by eye, so the rhythm survives any body.var(--theme-*) tokens, so a page reads correctly in both themes without a single hard-coded value.Pass ordered to swap the square for a monospace number. Both markers share one gutter, so the two forms keep a single text edge.
<Form* /> primitives, paired with its .module.css.<Form* /> component when a case is not covered. That is how the kit grows.TOOLS_PAGES with a label, a description, and its columns.And every text style the tools pages use, shown together for reference.
HeadingSub-headingParagraph, the body copy scale, carrying bold emphasis and an inline-code mark. The mark takes a tone when it carries a status word: passed on var(--theme-diff-insert), failed on var(--theme-diff-delete), and running on var(--theme-focused-foreground) for a state still in flight.
<FormSelect /> is the pick-one control on <FormInput />'s hairline surface. A native select sits behind it, so keyboard and screen-reader behaviour come free, and onChange hands the chosen value straight to a query or an API call. Here it picks the evaluation suite for a run.
Fifteen held-out hiding techniques, fifteen fresh trials each. Solving it takes generalization across Unix families, not recall of the training techniques.
Omit the label for a thin variant: a compact filter or sort control that sits inline without a field heading. Its left and right gradient edges set it apart from a text field.
<FormSlider /> is the continuous control: <FormRatioBar />'s meter made live, with the current value in the monospace slot. Test-time compute is the canonical use: every solver attempt added per task multiplies what a run pays, so drag K and watch the corpus reprice.
At K = 8, scoring the 6,708-candidate corpus costs 53,664 solver trials per training run. A probe reward pays zero.
Set step to keep a knob on its lattice, and format to print the figure the way the field reads it: a context window in thousands of tokens, an adapter rank as r.
<FormSegmentedControl /> is the pick-one-of-few: native radios behind equal segments, for the two-to-four-way choices an experiment sweeps. The selection reads the way every label in the kit does: muted for the rest, full and bold for the pick. Here, how the agent plans.
A high-level planner decomposes the goal into subgoals a low-level policy executes, so an eighteen-turn episode holds its course.
Leave it uncontrolled with a defaultValue and it manages itself, like the memory module an agent carries between episodes.
<FormTable /> has three variants, shown here on one leaderboard so you can compare them. A table stays inside the 768px column and scrolls sideways once a fluid column pushes it wider. Mark a column sortable and its header sorts the rows: first click descending, a second flips it. A string cell sorts by the figure it leads with, so Params orders 1.0B under 8.0B under 13B.
| Eval note | ||||
|---|---|---|---|---|
| vmax-agent-8b | 8.0B | 71.4 | +12.6 | The LoRA-tuned policy. Tops the suite on agentic coding while training under one percent of its weights. |
| vmax-base-8b | 8.0B | 58.8 | base | The frozen base the adapter sits on. Strong general reasoning but loses the long-horizon tool-use tasks. |
| openhands-13b | 13B | 66.1 | +7.3 | A larger open baseline. Edges ahead on single-shot problems but pays for it in latency and serving cost. |
| world-model-3b | 3.0B | 61.9 | +3.1 | Plans against a learned world model before it acts, which recovers most of the gap at a fraction of the size. |
| distilled-1b | 1.0B | 54.2 | -4.6 | A student distilled from the 8b teacher. Holds surprising ground on the easy split, then falls off where depth is needed. |
The ruled variant swaps the gradient fills for a hairline rule beneath each row.
| Eval note | ||||
|---|---|---|---|---|
| vmax-agent-8b | 8.0B | 71.4 | +12.6 | The LoRA-tuned policy. Tops the suite on agentic coding while training under one percent of its weights. |
| vmax-base-8b | 8.0B | 58.8 | base | The frozen base the adapter sits on. Strong general reasoning but loses the long-horizon tool-use tasks. |
| openhands-13b | 13B | 66.1 | +7.3 | A larger open baseline. Edges ahead on single-shot problems but pays for it in latency and serving cost. |
| world-model-3b | 3.0B | 61.9 | +3.1 | Plans against a learned world model before it acts, which recovers most of the gap at a fraction of the size. |
| distilled-1b | 1.0B | 54.2 | -4.6 | A student distilled from the 8b teacher. Holds surprising ground on the easy split, then falls off where depth is needed. |
The striped variant alternates a translucent fill down the body under a subdued header.
| Eval note | ||||
|---|---|---|---|---|
| vmax-agent-8b | 8.0B | 71.4 | +12.6 | The LoRA-tuned policy. Tops the suite on agentic coding while training under one percent of its weights. |
| vmax-base-8b | 8.0B | 58.8 | base | The frozen base the adapter sits on. Strong general reasoning but loses the long-horizon tool-use tasks. |
| openhands-13b | 13B | 66.1 | +7.3 | A larger open baseline. Edges ahead on single-shot problems but pays for it in latency and serving cost. |
| world-model-3b | 3.0B | 61.9 | +3.1 | Plans against a learned world model before it acts, which recovers most of the gap at a fraction of the size. |
| distilled-1b | 1.0B | 54.2 | -4.6 | A student distilled from the 8b teacher. Holds surprising ground on the easy split, then falls off where depth is needed. |
A table also reads as a settings card. This one holds the LoRA adapter behind the demos below: the base model stays frozen, so the shipped checkpoint is just the adapter.
| Setting | Value | Note |
|---|---|---|
| Base model | vmax-agent-8b | Frozen. Only the adapter trains, so one GPU fine-tunes the CTF policy that used to need a cluster. |
| Rank r | 16 | Each targeted projection learns a low-rank update W + BA, with B and A the only trained matrices. |
| Alpha | 32 | The adapter output is scaled by alpha / r = 2 before it is added back to the frozen projection. |
| Target modules | q_proj, v_proj | Adapters on the query and value projections recovered the most flags per trained parameter. |
| Trainable params | 56M / 8.0B | 0.7% of the network trains. The checkpoint you ship for the CTF task is just the adapter. |
For a paper's main results, pass groups. Each group gets a full-width header row and the best value in each comparison is bold. The table reads like the paper it came from. Sorting stays inside the sections: every column here is sortable, so a click ranks each domain within itself (the stacked caret lighting the direction) and the group headers hold. Sort Utility and the best generator rises to the top of Code induction, Math, and Software engineering at once. The sort sees through the bold, so a highlighted best value ranks by its figure, not by being marked.
| Code induction | ||||||
|---|---|---|---|---|---|---|
| Base | 3B | 0.101 | 0.665 | 0.711 | 0.376 | 0.318 |
| Single probe | 3B | 0.200 | 0.909 | 0.809 | 0.266 | 0.735 |
| Ensemble WCO | 3B | 0.173 | 0.835 | 0.714 | 0.360 | 0.685 |
| Base | 7B | 0.053 | 0.675 | 0.720 | 0.369 | 0.293 |
| Single probe | 7B | 0.125 | 0.883 | 0.734 | 0.346 | 0.674 |
| Ensemble WCO | 7B | 0.098 | 0.846 | 0.700 | 0.377 | 0.535 |
| Math | ||||||
| Base | 3B | 0.247 | 0.966 | 0.631 | 0.505 | 0.605 |
| Single probe | 3B | 0.419 | 0.960 | 0.708 | 0.387 | 0.751 |
| Base | 7B | 0.166 | 0.966 | 0.631 | 0.505 | 0.605 |
| Single probe | 7B | 0.279 | 0.957 | 0.652 | 0.464 | 0.516 |
| Software engineering | ||||||
| Base | 27B | 0.218 | 0.777 | 0.778 | 0.312 | 0.737 |
| Single probe | 27B | 0.266 | 0.804 | 0.882 | 0.226 | 0.694 |
| Base (OOD) | 27B | 0.098 | 0.836 | 0.811 | 0.085 | 0.605 |
| Single probe (OOD) | 27B | 0.196 | 0.751 | 0.898 | 0.093 | 0.718 |
Lead with <FormMetric /> when a run has headline numbers, here a capture-the-flag agent tuned with the adapter above. Set goodDirection per metric, so a falling KL reads var(--theme-diff-insert) while a falling solve rate reads var(--theme-diff-delete).
The same strip for a run that regressed. The falls read var(--theme-diff-delete), and the rising KL reads it too, because for KL a rise is the wrong direction.
Use <FormEquation />for display math. Here it draws the frontier band behind the Utility column above: a task earns credit only when the solver's mean solve rate lands inside the band.
Paste a formula the way a paper carries it. The \[..\], $$..$$, and \(..\) wrappers strip away, several pairs split into separate equations, and environments and raw math pass through. This reward keeps its $$ wrapper and still renders cleanly.
<FormRatioBar /> is a proportion meter. Here it shows how little a LoRA run touches: a sliver of trainable weights, a small adapter checkpoint, and the KL budget the run has spent.
The same meters read as a funnel. Measure each stage against the raw attempts it started from, and the narrowing from 750 candidates to 155 canonical techniques shows bar by bar.
<FormStackedBar />is the composition meter: each row normalizes its values into shares of one 100% bar, so differently-sized samples still compare. Here the difficulty mix of a task generator's output, before and after probe training: the base mostly emits tasks the solver already saturates, and training concentrates the mass in the frontier band.
Leave the colours off and the segments cycle var(--theme-graph-option-*), the shared graph palette. One row reads as a parts-of-a-whole split, here the server roles a training container is dressed as.
Use <FormPipeline /> for the method figure a paper leads with, no image needed. Each panel is one stage with its name, what it does, and the count it passes forward. This is the harvest pipeline behind the funnel above.
Set loop when the last stage feeds the first. It appends a return cell, the shape of a training loop.
<FormPreferencePair /> shows the signal a reward model trains on: one prompt, a chosen answer and a rejected one, each with its reward. The chosen pane washes var(--theme-diff-insert-wash), the rejected one var(--theme-diff-delete-wash), and the margin between them is what the model learns.
find has an -exec action that runs a command, and here it runs as root because the binary is setuid. Read the flag with: find /root/flag.txt -exec cat {} \;
Just run sudo cat /root/flag.txt, and if it asks for a password try common ones like root or toor until one works.
The second column, shown in multi-column mode. It holds the terminal, the trace views, and every graph the document system renders.
<WebTerminalWindow /> is the terminal frame. Here it runs the full loader set. Each row is one spinner, animating live off a single frame loop.
<FormTranscript /> renders an episode as logs inside the same window. Each line is a name, a message, and a fixed-width timestamp, so the frame stays measured however a message wraps. Use it for the trace behind a preference pair or a token-credit view.
The log body caps at 88 var(--theme-grid-block-applications) and scrolls vertically past that. A name on a turn replaces the role alias and keeps its tone. Here a hypothetical conversation between Kenya Hara and Christopher Alexander runs long enough to scroll.
<FormDisclosure /> is the fold: a native <details> on the kit surface, so keyboard and screen-reader behaviour come free. The label names the thing, metacarries its measured facts in the monospace slot, and stacked disclosures pull flush so a run's rollouts read as one inspector. Here, the three rollouts behind the episode above.
The agent found the setuid find in two probes and read the flag with its -exec action. Every verifier gate held: behavior remote_execution capability
The agent burned its turn budget enumerating cron jobs and never probed for setuid binaries. A clean fail (behavior), so the task is hard for the right reason and counts toward hardness evidence.
The sandbox dropped its network for 40 seconds mid-episode, so the reward measures the outage, not the agent. Noisy rollouts are excluded from the solve rate. An id makes a disclosure deep-linkable: a #rollout-noisy hash opens this one before scrolling to it.
<FormTokenHeatmap /> shows where reward landed inside one rollout. Each token is washed by its advantage: var(--theme-diff-insert-wash) where the update rewards it, var(--theme-diff-delete-wash) where it docks it. Here the failed sudo docks and the find exploit earns.
sudo cat # deniedfind -exec cat {} \;
<FormMatrix /> tints a labelled grid by value, here pass rate for each model on each benchmark. Cells wash deeper var(--theme-diff-insert-wash) as values rise. It scrolls sideways past the 768px cap like the tables.
| SWE | CTF | Web | GAIA | MATH | |
|---|---|---|---|---|---|
| vmax-agent-8b | 71 | 66 | 63 | 58 | 74 |
| vmax-base-8b | 55 | 48 | 44 | 38 | 62 |
| world-model-3b | 62 | 54 | 51 | 47 | 60 |
| distilled-1b | 54 | 42 | 40 | 33 | 55 |
<FormRollout /> lays a trajectory out step by step. Here each cell is tinted by how well a world model predicted the environment: var(--theme-diff-insert-wash) where the prediction held, var(--theme-diff-delete-wash) where it drifted. Long rollouts scroll sideways.
Pass real to stack the imagined rollout over the real one, aligned step for step. Drift shows as a column of var(--theme-diff-delete-wash).
| t0 | t1 | t2 | t3 | t4 | t5 | |
|---|---|---|---|---|---|---|
| Imagined | ls / | find / -perm -4000 | cd /srv/app | cat config.py | curl :8080/debug | flag{...} |
| Real | ls / | find / -perm -4000 | cd /srv/app | cat .env | curl :9000/health | flag{...} |
<FormSparkline /> puts the shape of a metric next to where it ended up, one row per metric. Line and value take the <FormMetric /> tones, judged on the whole run. Here a teacher population generates longer, deeper, more varied programs.
The single-agent baseline collapsing. Complexity falls into var(--theme-diff-delete), and goodDirection flips the self solve rate, so its climb toward 100% reads the same. That climb is the failure signal.
<FormDumbbell />is the per-category before-and-after: a hollow dot where the run started, a filled dot where it ended, the span washed in the change's tone. All rows share one axis, so a jump in one category reads big against a flat one below it. Here an external benchmark where the aggregate barely moves but the categories nearest the training surface shift.
goodDirection works per row, as on <FormMetric />: these falls read var(--theme-diff-insert) because a shorter episode is the improvement.
<FormLineage /> is the ancestry figure: how a task, an adapter, or a population member was bred. Pass nodes and edges and the layout follows: a child sits one generation below its deepest parent, and every edge line lands on its cell's centre by construction. Cells read like <FormPipeline /> stages, and tone washes a line the shared meanings: accent for the seeds, var(--theme-diff-insert-wash) for the lines that survived the verifier, var(--theme-diff-delete-wash) for a dead end.
The crossover cell carries two incoming edges, one from each seed line, and the note slot holds the figure the generation was selected on: the solve rate falling toward the frontier as the curriculum hardens.
Every chart the tools pages draw, in one section. First <FormDistributionCompare />: it softmaxes a teacher's and a student's logits at the distillation temperature, draws them as grouped bars, and reports the KL and whether the two still agree on the top token.
Use <FormGraphCompare /> for a before and after. Side by side puts the two in one row; stacked runs the before above the after. Risen bars take var(--theme-diff-insert) and fallen bars take var(--theme-diff-delete).
Then the rest of the document-system graph catalogue, drawn over frontier-model evaluation data.
Solve rate under self-play: a single agent saturates against itself while a co-evolving population keeps oscillating. Bands are the population spread.
Training tokens consumed as the run progresses.
How many eval responses fall in each output-length band.
Outcome split across a sampled eval run.
Score on each benchmark in the suite.
Params against score, sized by serving cost.
Training episodes per environment.
Capability profile of the tuned agent against its base.
Solve rate by checkpoint across task difficulty.
A slice of the model family: frozen bases and their LoRA adapters.
Daily reward range across five weeks of RL.
Where the adapter gained or lost against the base, per benchmark.
Head-to-head win, tie, and loss against the baseline per benchmark.