Ask a frontier mannequin for a slide deck and you will get a great one. Ask for ten they usually begin to look alike: the identical tasteful defaults, the identical home type, a faint “AI-generated deck” look. That is wonderful till you need the deck to appear like your template. Frontier fashions have their very own home type, and no quantity of prompting stops them drifting again to it. And typically the content material is confidential and might’t go away your methods in any respect.
Each of these level to a mannequin you personal: open weights, working by yourself infrastructure, skilled by yourself design language. The catch is that small open fashions, the type you’d really self-host, are unhealthy at this. Their decks come out damaged: titles that vanish into the background, textual content working off the slide, shapes stacked on high of one another.
Palette assessments one guess: {that a} small open-weight mannequin, skilled on artificial knowledge in your design language and checked by a harness, can compete with frontier methods when you preserve possession of the end result. We fine-tuned a 20B mannequin to construct decks the best way folks do: a designer plans the deck and a coder attracts every slide. Its coaching knowledge follows the IBM Design Language, and on PresentBench it ranks first on two of the three domains we measured. This publish covers how we synthesized the info, skilled the mannequin and constructed a harness round it.
Why decks are arduous for small fashions
A slide deck appears to be like easy, however making one asks a mannequin to do three issues small fashions are unhealthy at.
It lays out the slide with out seeing it. The mannequin does not draw slides; it writes code that locations each aspect at an x, y, width and font measurement. Whether or not a 75-character title matches on two strains at 56pt is arithmetic the mannequin does in its head, and it solely finds out it was incorrect after the code renders. Small fashions get this incorrect typically, which is the place overlapping shapes and textual content working off the slide come from.
It makes two sorts of choices without delay. Deciding what every slide says and how you can present it (a chart or a desk? what to chop?) is editorial judgment. Putting it exactly is geometry. A single go has to do each throughout 10–20 slides, whereas preserving the palette, kind and structure constant.
There is not any knowledge displaying how decks get made. Loads of completed decks exist, however not the rationale behind the design decisions or the code that produced them.
Construct it like a human: a designer and a coder
No person makes a deck in a single go. You resolve the story first (what number of slides, what each says, which will get a chart and which will get a desk) and solely then construct every slide. Palette splits the work the identical method, into two roles served by a single LoRA adapter:
- The designer reads the plan and writes a structured JSON transient: the palette, the sort system, and for every slide its structure, its actual content material and a brief design rationale.
- The coder takes one slide’s spec from the transient and writes the pptxgenjs JavaScript that attracts it, preceded by its reasoning.
Every position now makes one sort of choice: the designer handles the editorial judgment, and the coder handles the geometry. The transient between them is readable and editable, so an individual or an agent can change one slide’s structure with out regenerating the deck. And since each slide’s context is fastened earlier than any code is written, the coder calls run in parallel, one per slide, which makes the coding stage about 6–7× quicker.
We skilled the adapter with LoRA relatively than full fine-tuning: it teaches a format and a talent on high of a succesful base with out disturbing what the bottom already is aware of, and it made every experiment low cost. One lesson: coder examples are about 5× longer than designer examples, so a naive combine undertrained the designer till we oversampled its examples 5×.
Synthesizing decks and their reasoning
There is not any public corpus of plans, design selections and slide code, so we generated one with a big open instructor. Every deck begins from a recipe that units its style, size, layouts and any consumer directives, so we management what the info covers. Plans vary from tidy outlines to uncooked content material dumps, so the mannequin learns to chop and condense. We generated round 1000 decks overlaying roughly 10,000 slides.
Each instance additionally carries the reasoning behind it, written as a counterfactual: the hint weighs an alternate and says why it was rejected, so the mannequin learns the rule behind a alternative, not simply the selection. The designer causes about content material and type. For instance:
“Income for 4 quarters, with one clear upward pattern. I thought of a desk, however the level of this slide is the pattern, not the precise figures, so a bar chart makes it seen at a look.”
The coder causes about geometry:
“The title is 62 characters. At 44pt it could wrap to a few strains and run into the chart beneath, so I set it at 36pt, which inserts on two strains and leaves room above the chart.”
The instructor alone does not make the info good; the loop round it does. Each synthesized deck is rendered and checked for overlaps and overflow by the identical checker the harness makes use of at inference. Damaged slides are repaired, and their reasoning is rewritten as the identical sort of counterfactual, overlaying what the unique structure bought incorrect and why the repair works. Every mistake the checker catches turns into a greater coaching instance.
The toughest drawback was faithfulness. The worst failure is a slide with info that weren’t within the enter, and we discovered {that a} immediate rule cannot stop it. If a quick asks for a six-by-five desk however carries solely three bullets, the coder has to invent the remainder.
What fastened it was reference decks, not the principles: fixing a reference reliably modified the instructor’s output, whereas including a rule not often did. The instructor sees a number of reference decks in its immediate and copies them excess of it follows directions.
Steering a deck in plain English
Customers typically need finer-grained management over particular design decisions: a chart as a substitute of a desk, a selected coloration, a darker cowl. Palette lets them ask for these with directives, brief directions written straight within the plan and wrapped in [[ ]]:
## Rollout plan
- March: pilot with two groups
- Might: safety assessment full
- July: rollout to all of engineering
- September: company-wide launch
- November: first adoption assessment
[[make this a timeline]]
The designer builds every directive into the transient, and the coder follows it when drawing the slide. With out the directive, the mannequin would fairly present these milestones as a desk; with it, the mannequin attracts a timeline as a substitute.
The mannequin follows directives as a result of it was skilled to. The information recipes embody directives from 12 classes, a number of of that are proven beneath, every phrased a number of alternative ways, so the mannequin learns the intent relatively than a set phrase.
| Class | Instance directive |
|---|---|
| Structure | [[make this a timeline]] |
| Tone | [[be candid, no spin]] |
| Viewers | [[this is for the board]] |
| Order | [[lead with the ask]] |
| Leaving out | [[no pricing]] |
| Emphasis | [[highlight the headline number]] |
Determine 1. An illustration of the identical plan with out (left) and with (proper) the [[make this a timeline]] directive.
Constructing a check-and-repair harness
Even a well-trained mannequin typically produces a damaged slide: a title in the identical coloration because the background, or two containers stacked on high of one another. So Palette does not return the mannequin’s output straight; each deck goes by means of a harness first.
Determine 2. The designer drafts the transient, the coder writes every slide’s code in parallel, and the harness checks and repairs each slide earlier than the deck is returned.
First, easy guidelines repair identified errors, corresponding to a malformed coloration code that will in any other case flip each slide black. Then every slide is rendered and measured: a geometry checker flags textual content that overlaps, will get clipped or runs off the slide. Flagged slides go to a separate editor mannequin, which rewrites that slide’s code.
The important thing rule is {that a} rewrite is stored provided that the checker confirms the slide improved; in any other case the unique stays. That makes the harness protected to run on each deck. It might probably repair a slide, however it could possibly’t make one worse.
Determine 3. An illustration of a restore. As generated (left), every card’s title is stacked on high of its description; the harness detects the overlaps and reflows the playing cards right into a 2×2 grid (proper).
To measure its impact, we generated every PresentBench deck as soon as and scored it with and with out the harness. Throughout 131 decks, the harness provides 3.5 factors on common.
Analysis
We consider on PresentBench, which scores generated decks on 5 standards: fundamentals, visible design, completeness, correctness and constancy. PresentBench offers a supply doc relatively than a plan, so for these runs a separate frontier mannequin drafted every plan from its doc, and Palette constructed the deck from that plan. We report three domains; baseline numbers are from the PresentBench paper.
Determine 4. PresentBench scores by area. Palette (blue) in opposition to NotebookLM, Manus 1.6 and 5 different methods (grey). Palette ranks first on Economics and Training, third on Discuss, and second on the three-domain imply.
Palette does greatest the place structured content material and numeric accuracy resolve the rating, rating first on Economics and Training. On Discuss, the place decks are narrative and speech-driven, two closed methods rating increased and Palette locations third. Throughout the three domains it locations second, 1.1 factors behind NotebookLM (59.7 vs 60.8) and forward of the remainder of the sector, as a single 20B open-weight mannequin.
PresentBench measures whether or not a deck is nice, however not whether or not it follows a selected design language. We’re not conscious of a benchmark that does, and it is a hole we hope to assist shut.
What’s subsequent
The harness already computes low cost, verifiable indicators: does the slide render, does something overlap or overflow, does each reality hint again to the transient. At the moment we use them to restore output after technology. Subsequent, we need to use the identical checks as rewards for reinforcement studying, so the mannequin stops making these errors within the first place. As a result of the coder works one slide at a time, every slide is a brief, independently checkable rollout, a pure match for GRPO-style coaching.
We additionally need to shut the hole on figure-heavy decks by extracting figures from supply paperwork (e.g. with Docling) and inserting them with the harness. And we’re exploring a lighter solution to convey your individual templates: re-skinning output from one or two of your current .pptx information, with out retraining.
What we realized
Constructing Palette taught us a number of efficient strategies that reach naturally to different duties whose output has a construction you’ll be able to test in code, from charts and diagrams to UI layouts:
- Put the reasoning within the knowledge. Coaching on why a alternative was made, together with what was rejected, teaches greater than the selection alone.
- Repair the examples earlier than including a rule. When the instructor bought one thing incorrect, our first intuition was so as to add a rule to its immediate, and that not often helped. The instructor copied its reference decks excess of it adopted directions, so fixing the reference was what really modified its output.
- Make repairs protected by default. A repair that is stored solely when it measurably helps can run on each output.
- Construct the checker first. It is what makes the info reliable and the outputs protected to ship.
